]>
Commit | Line | Data |
---|---|---|
f739fcd8 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
bee91169 AG |
2 | /* |
3 | * EFI application boot time services | |
4 | * | |
5 | * Copyright (c) 2016 Alexander Graf | |
bee91169 AG |
6 | */ |
7 | ||
bee91169 | 8 | #include <common.h> |
7d963323 | 9 | #include <div64.h> |
bee91169 | 10 | #include <efi_loader.h> |
ad644e7c | 11 | #include <environment.h> |
bee91169 | 12 | #include <malloc.h> |
b08c8c48 | 13 | #include <linux/libfdt_env.h> |
bee91169 AG |
14 | #include <u-boot/crc.h> |
15 | #include <bootm.h> | |
bee91169 AG |
16 | #include <watchdog.h> |
17 | ||
18 | DECLARE_GLOBAL_DATA_PTR; | |
19 | ||
32f4b2f8 | 20 | /* Task priority level */ |
152cade3 | 21 | static efi_uintn_t efi_tpl = TPL_APPLICATION; |
32f4b2f8 | 22 | |
bee91169 AG |
23 | /* This list contains all the EFI objects our payload has access to */ |
24 | LIST_HEAD(efi_obj_list); | |
25 | ||
43bce442 | 26 | /* List of all events */ |
b095f3c8 | 27 | LIST_HEAD(efi_events); |
43bce442 | 28 | |
bb31c3f7 HS |
29 | /* Handle of the currently executing image */ |
30 | static efi_handle_t current_image; | |
31 | ||
f31239ac AG |
32 | /* |
33 | * If we're running on nasty systems (32bit ARM booting into non-EFI Linux) | |
34 | * we need to do trickery with caches. Since we don't want to break the EFI | |
35 | * aware boot path, only apply hacks when loading exiting directly (breaking | |
36 | * direct Linux EFI booting along the way - oh well). | |
37 | */ | |
38 | static bool efi_is_direct_boot = true; | |
39 | ||
65e4c0b1 | 40 | #ifdef CONFIG_ARM |
bee91169 AG |
41 | /* |
42 | * The "gd" pointer lives in a register on ARM and AArch64 that we declare | |
43 | * fixed when compiling U-Boot. However, the payload does not know about that | |
44 | * restriction so we need to manually swap its and our view of that register on | |
45 | * EFI callback entry/exit. | |
46 | */ | |
47 | static volatile void *efi_gd, *app_gd; | |
65e4c0b1 | 48 | #endif |
bee91169 | 49 | |
914df75b HS |
50 | /* 1 if inside U-Boot code, 0 if inside EFI payload code */ |
51 | static int entry_count = 1; | |
af65db85 | 52 | static int nesting_level; |
bc4f9133 HS |
53 | /* GUID of the device tree table */ |
54 | const efi_guid_t efi_guid_fdt = EFI_FDT_GUID; | |
f0959dbe HS |
55 | /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ |
56 | const efi_guid_t efi_guid_driver_binding_protocol = | |
57 | EFI_DRIVER_BINDING_PROTOCOL_GUID; | |
c160d2f5 | 58 | |
a3a28f5f HS |
59 | /* event group ExitBootServices() invoked */ |
60 | const efi_guid_t efi_guid_event_group_exit_boot_services = | |
61 | EFI_EVENT_GROUP_EXIT_BOOT_SERVICES; | |
62 | /* event group SetVirtualAddressMap() invoked */ | |
63 | const efi_guid_t efi_guid_event_group_virtual_address_change = | |
64 | EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE; | |
65 | /* event group memory map changed */ | |
66 | const efi_guid_t efi_guid_event_group_memory_map_change = | |
67 | EFI_EVENT_GROUP_MEMORY_MAP_CHANGE; | |
68 | /* event group boot manager about to boot */ | |
69 | const efi_guid_t efi_guid_event_group_ready_to_boot = | |
70 | EFI_EVENT_GROUP_READY_TO_BOOT; | |
71 | /* event group ResetSystem() invoked (before ExitBootServices) */ | |
72 | const efi_guid_t efi_guid_event_group_reset_system = | |
73 | EFI_EVENT_GROUP_RESET_SYSTEM; | |
74 | ||
2074f700 HS |
75 | static efi_status_t EFIAPI efi_disconnect_controller( |
76 | efi_handle_t controller_handle, | |
77 | efi_handle_t driver_image_handle, | |
78 | efi_handle_t child_handle); | |
3f9b0042 | 79 | |
c160d2f5 RC |
80 | /* Called on every callback entry */ |
81 | int __efi_entry_check(void) | |
82 | { | |
83 | int ret = entry_count++ == 0; | |
84 | #ifdef CONFIG_ARM | |
85 | assert(efi_gd); | |
86 | app_gd = gd; | |
87 | gd = efi_gd; | |
88 | #endif | |
89 | return ret; | |
90 | } | |
91 | ||
92 | /* Called on every callback exit */ | |
93 | int __efi_exit_check(void) | |
94 | { | |
95 | int ret = --entry_count == 0; | |
96 | #ifdef CONFIG_ARM | |
97 | gd = app_gd; | |
98 | #endif | |
99 | return ret; | |
100 | } | |
101 | ||
bee91169 AG |
102 | /* Called from do_bootefi_exec() */ |
103 | void efi_save_gd(void) | |
104 | { | |
65e4c0b1 | 105 | #ifdef CONFIG_ARM |
bee91169 | 106 | efi_gd = gd; |
65e4c0b1 | 107 | #endif |
bee91169 AG |
108 | } |
109 | ||
c160d2f5 | 110 | /* |
78a88f79 | 111 | * Special case handler for error/abort that just forces things back to u-boot |
b72aaa87 HS |
112 | * world so we can dump out an abort message, without any care about returning |
113 | * back to UEFI world. | |
c160d2f5 | 114 | */ |
bee91169 AG |
115 | void efi_restore_gd(void) |
116 | { | |
65e4c0b1 | 117 | #ifdef CONFIG_ARM |
bee91169 AG |
118 | /* Only restore if we're already in EFI context */ |
119 | if (!efi_gd) | |
120 | return; | |
bee91169 | 121 | gd = efi_gd; |
65e4c0b1 | 122 | #endif |
bee91169 AG |
123 | } |
124 | ||
6b03cd10 | 125 | /** |
78a88f79 MS |
126 | * indent_string() - returns a string for indenting with two spaces per level |
127 | * @level: indent level | |
6b03cd10 HS |
128 | * |
129 | * A maximum of ten indent levels is supported. Higher indent levels will be | |
130 | * truncated. | |
c8df80c5 | 131 | * |
78a88f79 MS |
132 | * Return: A string for indenting with two spaces per level is |
133 | * returned. | |
af65db85 RC |
134 | */ |
135 | static const char *indent_string(int level) | |
136 | { | |
137 | const char *indent = " "; | |
138 | const int max = strlen(indent); | |
ab9efa97 | 139 | |
af65db85 RC |
140 | level = min(max, level * 2); |
141 | return &indent[max - level]; | |
142 | } | |
143 | ||
ae0bd3a9 HS |
144 | const char *__efi_nesting(void) |
145 | { | |
146 | return indent_string(nesting_level); | |
147 | } | |
148 | ||
af65db85 RC |
149 | const char *__efi_nesting_inc(void) |
150 | { | |
151 | return indent_string(nesting_level++); | |
152 | } | |
153 | ||
154 | const char *__efi_nesting_dec(void) | |
155 | { | |
156 | return indent_string(--nesting_level); | |
157 | } | |
158 | ||
6b03cd10 | 159 | /** |
78a88f79 MS |
160 | * efi_queue_event() - queue an EFI event |
161 | * @event: event to signal | |
162 | * @check_tpl: check the TPL level | |
332468f7 HS |
163 | * |
164 | * This function queues the notification function of the event for future | |
165 | * execution. | |
166 | * | |
78a88f79 MS |
167 | * The notification function is called if the task priority level of the event |
168 | * is higher than the current task priority level. | |
332468f7 HS |
169 | * |
170 | * For the SignalEvent service see efi_signal_event_ext. | |
171 | * | |
332468f7 | 172 | */ |
b095f3c8 | 173 | static void efi_queue_event(struct efi_event *event, bool check_tpl) |
c6841592 | 174 | { |
ca62a4f5 | 175 | if (event->notify_function) { |
e190e897 | 176 | event->is_queued = true; |
32f4b2f8 | 177 | /* Check TPL */ |
9bc9664d | 178 | if (check_tpl && efi_tpl >= event->notify_tpl) |
32f4b2f8 | 179 | return; |
ea630ce9 HS |
180 | EFI_CALL_VOID(event->notify_function(event, |
181 | event->notify_context)); | |
c6841592 | 182 | } |
e190e897 | 183 | event->is_queued = false; |
c6841592 HS |
184 | } |
185 | ||
21b3edfc HS |
186 | /** |
187 | * is_valid_tpl() - check if the task priority level is valid | |
188 | * | |
189 | * @tpl: TPL level to check | |
b72aaa87 | 190 | * Return: status code |
21b3edfc HS |
191 | */ |
192 | efi_status_t is_valid_tpl(efi_uintn_t tpl) | |
193 | { | |
194 | switch (tpl) { | |
195 | case TPL_APPLICATION: | |
196 | case TPL_CALLBACK: | |
197 | case TPL_NOTIFY: | |
198 | case TPL_HIGH_LEVEL: | |
199 | return EFI_SUCCESS; | |
200 | default: | |
201 | return EFI_INVALID_PARAMETER; | |
202 | } | |
203 | } | |
204 | ||
6b03cd10 | 205 | /** |
78a88f79 MS |
206 | * efi_signal_event() - signal an EFI event |
207 | * @event: event to signal | |
208 | * @check_tpl: check the TPL level | |
b095f3c8 | 209 | * |
78a88f79 MS |
210 | * This function signals an event. If the event belongs to an event group all |
211 | * events of the group are signaled. If they are of type EVT_NOTIFY_SIGNAL | |
b095f3c8 HS |
212 | * their notification function is queued. |
213 | * | |
214 | * For the SignalEvent service see efi_signal_event_ext. | |
b095f3c8 HS |
215 | */ |
216 | void efi_signal_event(struct efi_event *event, bool check_tpl) | |
217 | { | |
218 | if (event->group) { | |
219 | struct efi_event *evt; | |
220 | ||
221 | /* | |
222 | * The signaled state has to set before executing any | |
223 | * notification function | |
224 | */ | |
225 | list_for_each_entry(evt, &efi_events, link) { | |
226 | if (!evt->group || guidcmp(evt->group, event->group)) | |
227 | continue; | |
228 | if (evt->is_signaled) | |
229 | continue; | |
230 | evt->is_signaled = true; | |
231 | if (evt->type & EVT_NOTIFY_SIGNAL && | |
232 | evt->notify_function) | |
233 | evt->is_queued = true; | |
234 | } | |
235 | list_for_each_entry(evt, &efi_events, link) { | |
236 | if (!evt->group || guidcmp(evt->group, event->group)) | |
237 | continue; | |
238 | if (evt->is_queued) | |
239 | efi_queue_event(evt, check_tpl); | |
240 | } | |
241 | } else if (!event->is_signaled) { | |
242 | event->is_signaled = true; | |
243 | if (event->type & EVT_NOTIFY_SIGNAL) | |
244 | efi_queue_event(event, check_tpl); | |
245 | } | |
246 | } | |
247 | ||
6b03cd10 | 248 | /** |
78a88f79 MS |
249 | * efi_raise_tpl() - raise the task priority level |
250 | * @new_tpl: new value of the task priority level | |
332468f7 HS |
251 | * |
252 | * This function implements the RaiseTpl service. | |
332468f7 | 253 | * |
78a88f79 MS |
254 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
255 | * details. | |
256 | * | |
257 | * Return: old value of the task priority level | |
332468f7 | 258 | */ |
152cade3 | 259 | static unsigned long EFIAPI efi_raise_tpl(efi_uintn_t new_tpl) |
bee91169 | 260 | { |
152cade3 | 261 | efi_uintn_t old_tpl = efi_tpl; |
32f4b2f8 | 262 | |
503f2695 | 263 | EFI_ENTRY("0x%zx", new_tpl); |
32f4b2f8 HS |
264 | |
265 | if (new_tpl < efi_tpl) | |
266 | debug("WARNING: new_tpl < current_tpl in %s\n", __func__); | |
267 | efi_tpl = new_tpl; | |
268 | if (efi_tpl > TPL_HIGH_LEVEL) | |
269 | efi_tpl = TPL_HIGH_LEVEL; | |
270 | ||
271 | EFI_EXIT(EFI_SUCCESS); | |
272 | return old_tpl; | |
bee91169 AG |
273 | } |
274 | ||
6b03cd10 | 275 | /** |
78a88f79 MS |
276 | * efi_restore_tpl() - lower the task priority level |
277 | * @old_tpl: value of the task priority level to be restored | |
332468f7 HS |
278 | * |
279 | * This function implements the RestoreTpl service. | |
332468f7 | 280 | * |
78a88f79 MS |
281 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
282 | * details. | |
332468f7 | 283 | */ |
152cade3 | 284 | static void EFIAPI efi_restore_tpl(efi_uintn_t old_tpl) |
bee91169 | 285 | { |
503f2695 | 286 | EFI_ENTRY("0x%zx", old_tpl); |
32f4b2f8 HS |
287 | |
288 | if (old_tpl > efi_tpl) | |
289 | debug("WARNING: old_tpl > current_tpl in %s\n", __func__); | |
290 | efi_tpl = old_tpl; | |
291 | if (efi_tpl > TPL_HIGH_LEVEL) | |
292 | efi_tpl = TPL_HIGH_LEVEL; | |
293 | ||
0f7fcc72 HS |
294 | /* |
295 | * Lowering the TPL may have made queued events eligible for execution. | |
296 | */ | |
297 | efi_timer_check(); | |
298 | ||
32f4b2f8 | 299 | EFI_EXIT(EFI_SUCCESS); |
bee91169 AG |
300 | } |
301 | ||
6b03cd10 | 302 | /** |
78a88f79 MS |
303 | * efi_allocate_pages_ext() - allocate memory pages |
304 | * @type: type of allocation to be performed | |
305 | * @memory_type: usage type of the allocated memory | |
306 | * @pages: number of pages to be allocated | |
307 | * @memory: allocated memory | |
332468f7 HS |
308 | * |
309 | * This function implements the AllocatePages service. | |
332468f7 | 310 | * |
78a88f79 MS |
311 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
312 | * details. | |
313 | * | |
314 | * Return: status code | |
332468f7 | 315 | */ |
6e0bf8d8 | 316 | static efi_status_t EFIAPI efi_allocate_pages_ext(int type, int memory_type, |
f5a2a938 | 317 | efi_uintn_t pages, |
6e0bf8d8 | 318 | uint64_t *memory) |
bee91169 AG |
319 | { |
320 | efi_status_t r; | |
321 | ||
f5a2a938 | 322 | EFI_ENTRY("%d, %d, 0x%zx, %p", type, memory_type, pages, memory); |
bee91169 AG |
323 | r = efi_allocate_pages(type, memory_type, pages, memory); |
324 | return EFI_EXIT(r); | |
325 | } | |
326 | ||
6b03cd10 | 327 | /** |
78a88f79 MS |
328 | * efi_free_pages_ext() - Free memory pages. |
329 | * @memory: start of the memory area to be freed | |
330 | * @pages: number of pages to be freed | |
332468f7 HS |
331 | * |
332 | * This function implements the FreePages service. | |
332468f7 | 333 | * |
78a88f79 MS |
334 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
335 | * details. | |
336 | * | |
337 | * Return: status code | |
332468f7 | 338 | */ |
6e0bf8d8 | 339 | static efi_status_t EFIAPI efi_free_pages_ext(uint64_t memory, |
f5a2a938 | 340 | efi_uintn_t pages) |
bee91169 AG |
341 | { |
342 | efi_status_t r; | |
343 | ||
dee37fc9 | 344 | EFI_ENTRY("%llx, 0x%zx", memory, pages); |
bee91169 AG |
345 | r = efi_free_pages(memory, pages); |
346 | return EFI_EXIT(r); | |
347 | } | |
348 | ||
6b03cd10 | 349 | /** |
78a88f79 MS |
350 | * efi_get_memory_map_ext() - get map describing memory usage |
351 | * @memory_map_size: on entry the size, in bytes, of the memory map buffer, | |
352 | * on exit the size of the copied memory map | |
353 | * @memory_map: buffer to which the memory map is written | |
354 | * @map_key: key for the memory map | |
355 | * @descriptor_size: size of an individual memory descriptor | |
356 | * @descriptor_version: version number of the memory descriptor structure | |
332468f7 HS |
357 | * |
358 | * This function implements the GetMemoryMap service. | |
332468f7 | 359 | * |
78a88f79 MS |
360 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
361 | * details. | |
362 | * | |
363 | * Return: status code | |
332468f7 | 364 | */ |
6e0bf8d8 | 365 | static efi_status_t EFIAPI efi_get_memory_map_ext( |
f5a2a938 | 366 | efi_uintn_t *memory_map_size, |
6e0bf8d8 | 367 | struct efi_mem_desc *memory_map, |
f5a2a938 HS |
368 | efi_uintn_t *map_key, |
369 | efi_uintn_t *descriptor_size, | |
6e0bf8d8 | 370 | uint32_t *descriptor_version) |
bee91169 AG |
371 | { |
372 | efi_status_t r; | |
373 | ||
374 | EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size, memory_map, | |
375 | map_key, descriptor_size, descriptor_version); | |
376 | r = efi_get_memory_map(memory_map_size, memory_map, map_key, | |
377 | descriptor_size, descriptor_version); | |
378 | return EFI_EXIT(r); | |
379 | } | |
380 | ||
6b03cd10 | 381 | /** |
78a88f79 MS |
382 | * efi_allocate_pool_ext() - allocate memory from pool |
383 | * @pool_type: type of the pool from which memory is to be allocated | |
384 | * @size: number of bytes to be allocated | |
385 | * @buffer: allocated memory | |
332468f7 HS |
386 | * |
387 | * This function implements the AllocatePool service. | |
332468f7 | 388 | * |
78a88f79 MS |
389 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
390 | * details. | |
391 | * | |
392 | * Return: status code | |
332468f7 | 393 | */ |
ead1274b | 394 | static efi_status_t EFIAPI efi_allocate_pool_ext(int pool_type, |
f5a2a938 | 395 | efi_uintn_t size, |
ead1274b | 396 | void **buffer) |
bee91169 | 397 | { |
1cd29f0a AG |
398 | efi_status_t r; |
399 | ||
f5a2a938 | 400 | EFI_ENTRY("%d, %zd, %p", pool_type, size, buffer); |
ead1274b | 401 | r = efi_allocate_pool(pool_type, size, buffer); |
1cd29f0a | 402 | return EFI_EXIT(r); |
bee91169 AG |
403 | } |
404 | ||
6b03cd10 | 405 | /** |
78a88f79 MS |
406 | * efi_free_pool_ext() - free memory from pool |
407 | * @buffer: start of memory to be freed | |
332468f7 HS |
408 | * |
409 | * This function implements the FreePool service. | |
332468f7 | 410 | * |
78a88f79 MS |
411 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
412 | * details. | |
413 | * | |
414 | * Return: status code | |
332468f7 | 415 | */ |
42417bc8 | 416 | static efi_status_t EFIAPI efi_free_pool_ext(void *buffer) |
bee91169 | 417 | { |
1cd29f0a AG |
418 | efi_status_t r; |
419 | ||
420 | EFI_ENTRY("%p", buffer); | |
42417bc8 | 421 | r = efi_free_pool(buffer); |
1cd29f0a | 422 | return EFI_EXIT(r); |
bee91169 AG |
423 | } |
424 | ||
6b03cd10 | 425 | /** |
e6023be4 | 426 | * efi_add_handle() - add a new handle to the object list |
44549d62 | 427 | * |
e6023be4 HS |
428 | * @handle: handle to be added |
429 | * | |
430 | * The protocols list is initialized. The handle is added to the list of known | |
431 | * UEFI objects. | |
44549d62 | 432 | */ |
fae0118e | 433 | void efi_add_handle(efi_handle_t handle) |
44549d62 | 434 | { |
fae0118e | 435 | if (!handle) |
44549d62 | 436 | return; |
fae0118e HS |
437 | INIT_LIST_HEAD(&handle->protocols); |
438 | list_add_tail(&handle->link, &efi_obj_list); | |
44549d62 HS |
439 | } |
440 | ||
6b03cd10 | 441 | /** |
78a88f79 MS |
442 | * efi_create_handle() - create handle |
443 | * @handle: new handle | |
2edab5e2 | 444 | * |
78a88f79 | 445 | * Return: status code |
2edab5e2 | 446 | */ |
2074f700 | 447 | efi_status_t efi_create_handle(efi_handle_t *handle) |
3cc6e3fe HS |
448 | { |
449 | struct efi_object *obj; | |
3cc6e3fe | 450 | |
d29e7824 HS |
451 | obj = calloc(1, sizeof(struct efi_object)); |
452 | if (!obj) | |
453 | return EFI_OUT_OF_RESOURCES; | |
454 | ||
44549d62 | 455 | efi_add_handle(obj); |
fae0118e | 456 | *handle = obj; |
d29e7824 HS |
457 | |
458 | return EFI_SUCCESS; | |
3cc6e3fe HS |
459 | } |
460 | ||
6b03cd10 | 461 | /** |
78a88f79 MS |
462 | * efi_search_protocol() - find a protocol on a handle. |
463 | * @handle: handle | |
464 | * @protocol_guid: GUID of the protocol | |
465 | * @handler: reference to the protocol | |
678e03a0 | 466 | * |
78a88f79 | 467 | * Return: status code |
678e03a0 | 468 | */ |
2074f700 | 469 | efi_status_t efi_search_protocol(const efi_handle_t handle, |
678e03a0 HS |
470 | const efi_guid_t *protocol_guid, |
471 | struct efi_handler **handler) | |
472 | { | |
473 | struct efi_object *efiobj; | |
474 | struct list_head *lhandle; | |
475 | ||
476 | if (!handle || !protocol_guid) | |
477 | return EFI_INVALID_PARAMETER; | |
478 | efiobj = efi_search_obj(handle); | |
479 | if (!efiobj) | |
480 | return EFI_INVALID_PARAMETER; | |
481 | list_for_each(lhandle, &efiobj->protocols) { | |
482 | struct efi_handler *protocol; | |
483 | ||
484 | protocol = list_entry(lhandle, struct efi_handler, link); | |
485 | if (!guidcmp(protocol->guid, protocol_guid)) { | |
486 | if (handler) | |
487 | *handler = protocol; | |
488 | return EFI_SUCCESS; | |
489 | } | |
490 | } | |
491 | return EFI_NOT_FOUND; | |
492 | } | |
493 | ||
6b03cd10 | 494 | /** |
78a88f79 MS |
495 | * efi_remove_protocol() - delete protocol from a handle |
496 | * @handle: handle from which the protocol shall be deleted | |
497 | * @protocol: GUID of the protocol to be deleted | |
498 | * @protocol_interface: interface of the protocol implementation | |
678e03a0 | 499 | * |
78a88f79 | 500 | * Return: status code |
678e03a0 | 501 | */ |
2074f700 HS |
502 | efi_status_t efi_remove_protocol(const efi_handle_t handle, |
503 | const efi_guid_t *protocol, | |
678e03a0 HS |
504 | void *protocol_interface) |
505 | { | |
506 | struct efi_handler *handler; | |
507 | efi_status_t ret; | |
508 | ||
509 | ret = efi_search_protocol(handle, protocol, &handler); | |
510 | if (ret != EFI_SUCCESS) | |
511 | return ret; | |
512 | if (guidcmp(handler->guid, protocol)) | |
513 | return EFI_INVALID_PARAMETER; | |
1f470e17 HS |
514 | if (handler->protocol_interface != protocol_interface) |
515 | return EFI_INVALID_PARAMETER; | |
678e03a0 HS |
516 | list_del(&handler->link); |
517 | free(handler); | |
518 | return EFI_SUCCESS; | |
519 | } | |
520 | ||
6b03cd10 | 521 | /** |
78a88f79 MS |
522 | * efi_remove_all_protocols() - delete all protocols from a handle |
523 | * @handle: handle from which the protocols shall be deleted | |
678e03a0 | 524 | * |
78a88f79 | 525 | * Return: status code |
678e03a0 | 526 | */ |
2074f700 | 527 | efi_status_t efi_remove_all_protocols(const efi_handle_t handle) |
678e03a0 HS |
528 | { |
529 | struct efi_object *efiobj; | |
32e6fed6 HS |
530 | struct efi_handler *protocol; |
531 | struct efi_handler *pos; | |
678e03a0 HS |
532 | |
533 | efiobj = efi_search_obj(handle); | |
534 | if (!efiobj) | |
535 | return EFI_INVALID_PARAMETER; | |
32e6fed6 | 536 | list_for_each_entry_safe(protocol, pos, &efiobj->protocols, link) { |
678e03a0 HS |
537 | efi_status_t ret; |
538 | ||
678e03a0 HS |
539 | ret = efi_remove_protocol(handle, protocol->guid, |
540 | protocol->protocol_interface); | |
541 | if (ret != EFI_SUCCESS) | |
542 | return ret; | |
543 | } | |
544 | return EFI_SUCCESS; | |
545 | } | |
546 | ||
6b03cd10 | 547 | /** |
78a88f79 | 548 | * efi_delete_handle() - delete handle |
678e03a0 | 549 | * |
78a88f79 | 550 | * @obj: handle to delete |
678e03a0 | 551 | */ |
fae0118e | 552 | void efi_delete_handle(efi_handle_t handle) |
678e03a0 | 553 | { |
fae0118e | 554 | if (!handle) |
678e03a0 | 555 | return; |
fae0118e HS |
556 | efi_remove_all_protocols(handle); |
557 | list_del(&handle->link); | |
558 | free(handle); | |
678e03a0 HS |
559 | } |
560 | ||
6b03cd10 | 561 | /** |
78a88f79 MS |
562 | * efi_is_event() - check if a pointer is a valid event |
563 | * @event: pointer to check | |
43bce442 | 564 | * |
78a88f79 | 565 | * Return: status code |
bee91169 | 566 | */ |
43bce442 HS |
567 | static efi_status_t efi_is_event(const struct efi_event *event) |
568 | { | |
569 | const struct efi_event *evt; | |
570 | ||
571 | if (!event) | |
572 | return EFI_INVALID_PARAMETER; | |
573 | list_for_each_entry(evt, &efi_events, link) { | |
574 | if (evt == event) | |
575 | return EFI_SUCCESS; | |
576 | } | |
577 | return EFI_INVALID_PARAMETER; | |
578 | } | |
bee91169 | 579 | |
6b03cd10 | 580 | /** |
78a88f79 MS |
581 | * efi_create_event() - create an event |
582 | * @type: type of the event to create | |
583 | * @notify_tpl: task priority level of the event | |
584 | * @notify_function: notification function of the event | |
585 | * @notify_context: pointer passed to the notification function | |
586 | * @group: event group | |
587 | * @event: created event | |
332468f7 HS |
588 | * |
589 | * This function is used inside U-Boot code to create an event. | |
590 | * | |
591 | * For the API function implementing the CreateEvent service see | |
592 | * efi_create_event_ext. | |
593 | * | |
78a88f79 | 594 | * Return: status code |
332468f7 | 595 | */ |
152cade3 | 596 | efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, |
49deb455 | 597 | void (EFIAPI *notify_function) ( |
2fd945fe HS |
598 | struct efi_event *event, |
599 | void *context), | |
b095f3c8 HS |
600 | void *notify_context, efi_guid_t *group, |
601 | struct efi_event **event) | |
bee91169 | 602 | { |
43bce442 | 603 | struct efi_event *evt; |
c6841592 | 604 | |
a95343b8 | 605 | if (event == NULL) |
49deb455 | 606 | return EFI_INVALID_PARAMETER; |
a95343b8 | 607 | |
21b3edfc HS |
608 | switch (type) { |
609 | case 0: | |
610 | case EVT_TIMER: | |
611 | case EVT_NOTIFY_SIGNAL: | |
612 | case EVT_TIMER | EVT_NOTIFY_SIGNAL: | |
613 | case EVT_NOTIFY_WAIT: | |
614 | case EVT_TIMER | EVT_NOTIFY_WAIT: | |
615 | case EVT_SIGNAL_EXIT_BOOT_SERVICES: | |
616 | case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE: | |
617 | break; | |
618 | default: | |
49deb455 | 619 | return EFI_INVALID_PARAMETER; |
21b3edfc | 620 | } |
a95343b8 | 621 | |
3748ed90 | 622 | if ((type & (EVT_NOTIFY_WAIT | EVT_NOTIFY_SIGNAL)) && |
751e928d | 623 | (!notify_function || is_valid_tpl(notify_tpl) != EFI_SUCCESS)) |
49deb455 | 624 | return EFI_INVALID_PARAMETER; |
a95343b8 | 625 | |
43bce442 HS |
626 | evt = calloc(1, sizeof(struct efi_event)); |
627 | if (!evt) | |
628 | return EFI_OUT_OF_RESOURCES; | |
629 | evt->type = type; | |
630 | evt->notify_tpl = notify_tpl; | |
631 | evt->notify_function = notify_function; | |
632 | evt->notify_context = notify_context; | |
b095f3c8 | 633 | evt->group = group; |
b72aaa87 | 634 | /* Disable timers on boot up */ |
43bce442 HS |
635 | evt->trigger_next = -1ULL; |
636 | evt->is_queued = false; | |
637 | evt->is_signaled = false; | |
638 | list_add_tail(&evt->link, &efi_events); | |
639 | *event = evt; | |
640 | return EFI_SUCCESS; | |
bee91169 AG |
641 | } |
642 | ||
9f0930e5 | 643 | /* |
78a88f79 MS |
644 | * efi_create_event_ex() - create an event in a group |
645 | * @type: type of the event to create | |
646 | * @notify_tpl: task priority level of the event | |
647 | * @notify_function: notification function of the event | |
648 | * @notify_context: pointer passed to the notification function | |
649 | * @event: created event | |
650 | * @event_group: event group | |
9f0930e5 HS |
651 | * |
652 | * This function implements the CreateEventEx service. | |
9f0930e5 | 653 | * |
78a88f79 MS |
654 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
655 | * details. | |
656 | * | |
657 | * Return: status code | |
9f0930e5 HS |
658 | */ |
659 | efi_status_t EFIAPI efi_create_event_ex(uint32_t type, efi_uintn_t notify_tpl, | |
660 | void (EFIAPI *notify_function) ( | |
661 | struct efi_event *event, | |
662 | void *context), | |
663 | void *notify_context, | |
664 | efi_guid_t *event_group, | |
665 | struct efi_event **event) | |
666 | { | |
1884512b HS |
667 | efi_status_t ret; |
668 | ||
9f0930e5 HS |
669 | EFI_ENTRY("%d, 0x%zx, %p, %p, %pUl", type, notify_tpl, notify_function, |
670 | notify_context, event_group); | |
1884512b HS |
671 | |
672 | /* | |
673 | * The allowable input parameters are the same as in CreateEvent() | |
674 | * except for the following two disallowed event types. | |
675 | */ | |
676 | switch (type) { | |
677 | case EVT_SIGNAL_EXIT_BOOT_SERVICES: | |
678 | case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE: | |
679 | ret = EFI_INVALID_PARAMETER; | |
680 | goto out; | |
681 | } | |
682 | ||
683 | ret = efi_create_event(type, notify_tpl, notify_function, | |
684 | notify_context, event_group, event); | |
685 | out: | |
686 | return EFI_EXIT(ret); | |
9f0930e5 HS |
687 | } |
688 | ||
6b03cd10 | 689 | /** |
78a88f79 MS |
690 | * efi_create_event_ext() - create an event |
691 | * @type: type of the event to create | |
692 | * @notify_tpl: task priority level of the event | |
693 | * @notify_function: notification function of the event | |
694 | * @notify_context: pointer passed to the notification function | |
695 | * @event: created event | |
332468f7 HS |
696 | * |
697 | * This function implements the CreateEvent service. | |
332468f7 | 698 | * |
78a88f79 MS |
699 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
700 | * details. | |
701 | * | |
702 | * Return: status code | |
332468f7 | 703 | */ |
49deb455 | 704 | static efi_status_t EFIAPI efi_create_event_ext( |
152cade3 | 705 | uint32_t type, efi_uintn_t notify_tpl, |
49deb455 HS |
706 | void (EFIAPI *notify_function) ( |
707 | struct efi_event *event, | |
708 | void *context), | |
709 | void *notify_context, struct efi_event **event) | |
710 | { | |
711 | EFI_ENTRY("%d, 0x%zx, %p, %p", type, notify_tpl, notify_function, | |
712 | notify_context); | |
713 | return EFI_EXIT(efi_create_event(type, notify_tpl, notify_function, | |
b095f3c8 | 714 | notify_context, NULL, event)); |
49deb455 HS |
715 | } |
716 | ||
6b03cd10 | 717 | /** |
78a88f79 | 718 | * efi_timer_check() - check if a timer event has occurred |
6b03cd10 | 719 | * |
332468f7 HS |
720 | * Check if a timer event has occurred or a queued notification function should |
721 | * be called. | |
722 | * | |
bee91169 | 723 | * Our timers have to work without interrupts, so we check whenever keyboard |
332468f7 | 724 | * input or disk accesses happen if enough time elapsed for them to fire. |
bee91169 AG |
725 | */ |
726 | void efi_timer_check(void) | |
727 | { | |
43bce442 | 728 | struct efi_event *evt; |
bee91169 AG |
729 | u64 now = timer_get_us(); |
730 | ||
43bce442 HS |
731 | list_for_each_entry(evt, &efi_events, link) { |
732 | if (evt->is_queued) | |
b095f3c8 | 733 | efi_queue_event(evt, true); |
43bce442 | 734 | if (!(evt->type & EVT_TIMER) || now < evt->trigger_next) |
ca62a4f5 | 735 | continue; |
43bce442 | 736 | switch (evt->trigger_type) { |
ca62a4f5 | 737 | case EFI_TIMER_RELATIVE: |
43bce442 | 738 | evt->trigger_type = EFI_TIMER_STOP; |
ca62a4f5 HS |
739 | break; |
740 | case EFI_TIMER_PERIODIC: | |
43bce442 | 741 | evt->trigger_next += evt->trigger_time; |
ca62a4f5 HS |
742 | break; |
743 | default: | |
744 | continue; | |
c6841592 | 745 | } |
b095f3c8 | 746 | evt->is_signaled = false; |
43bce442 | 747 | efi_signal_event(evt, true); |
bee91169 | 748 | } |
bee91169 AG |
749 | WATCHDOG_RESET(); |
750 | } | |
751 | ||
6b03cd10 | 752 | /** |
78a88f79 MS |
753 | * efi_set_timer() - set the trigger time for a timer event or stop the event |
754 | * @event: event for which the timer is set | |
755 | * @type: type of the timer | |
b72aaa87 | 756 | * @trigger_time: trigger period in multiples of 100 ns |
332468f7 HS |
757 | * |
758 | * This is the function for internal usage in U-Boot. For the API function | |
759 | * implementing the SetTimer service see efi_set_timer_ext. | |
760 | * | |
78a88f79 | 761 | * Return: status code |
332468f7 | 762 | */ |
b521d29e | 763 | efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, |
bfc72462 | 764 | uint64_t trigger_time) |
bee91169 | 765 | { |
43bce442 HS |
766 | /* Check that the event is valid */ |
767 | if (efi_is_event(event) != EFI_SUCCESS || !(event->type & EVT_TIMER)) | |
768 | return EFI_INVALID_PARAMETER; | |
bee91169 | 769 | |
8787b02e | 770 | /* |
b72aaa87 HS |
771 | * The parameter defines a multiple of 100 ns. |
772 | * We use multiples of 1000 ns. So divide by 10. | |
8787b02e | 773 | */ |
7d963323 | 774 | do_div(trigger_time, 10); |
bee91169 | 775 | |
43bce442 HS |
776 | switch (type) { |
777 | case EFI_TIMER_STOP: | |
778 | event->trigger_next = -1ULL; | |
779 | break; | |
780 | case EFI_TIMER_PERIODIC: | |
781 | case EFI_TIMER_RELATIVE: | |
782 | event->trigger_next = timer_get_us() + trigger_time; | |
783 | break; | |
784 | default: | |
785 | return EFI_INVALID_PARAMETER; | |
bee91169 | 786 | } |
43bce442 HS |
787 | event->trigger_type = type; |
788 | event->trigger_time = trigger_time; | |
789 | event->is_signaled = false; | |
790 | return EFI_SUCCESS; | |
bfc72462 HS |
791 | } |
792 | ||
6b03cd10 | 793 | /** |
78a88f79 MS |
794 | * efi_set_timer_ext() - Set the trigger time for a timer event or stop the |
795 | * event | |
796 | * @event: event for which the timer is set | |
797 | * @type: type of the timer | |
b72aaa87 | 798 | * @trigger_time: trigger period in multiples of 100 ns |
332468f7 HS |
799 | * |
800 | * This function implements the SetTimer service. | |
332468f7 | 801 | * |
78a88f79 MS |
802 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
803 | * details. | |
804 | * | |
805 | * | |
806 | * Return: status code | |
332468f7 | 807 | */ |
b521d29e HS |
808 | static efi_status_t EFIAPI efi_set_timer_ext(struct efi_event *event, |
809 | enum efi_timer_delay type, | |
810 | uint64_t trigger_time) | |
bfc72462 | 811 | { |
dee37fc9 | 812 | EFI_ENTRY("%p, %d, %llx", event, type, trigger_time); |
bfc72462 | 813 | return EFI_EXIT(efi_set_timer(event, type, trigger_time)); |
bee91169 AG |
814 | } |
815 | ||
6b03cd10 | 816 | /** |
78a88f79 MS |
817 | * efi_wait_for_event() - wait for events to be signaled |
818 | * @num_events: number of events to be waited for | |
819 | * @event: events to be waited for | |
820 | * @index: index of the event that was signaled | |
332468f7 HS |
821 | * |
822 | * This function implements the WaitForEvent service. | |
332468f7 | 823 | * |
78a88f79 MS |
824 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
825 | * details. | |
826 | * | |
827 | * Return: status code | |
332468f7 | 828 | */ |
f5a2a938 | 829 | static efi_status_t EFIAPI efi_wait_for_event(efi_uintn_t num_events, |
2fd945fe | 830 | struct efi_event **event, |
f5a2a938 | 831 | efi_uintn_t *index) |
bee91169 | 832 | { |
43bce442 | 833 | int i; |
bee91169 | 834 | |
f5a2a938 | 835 | EFI_ENTRY("%zd, %p, %p", num_events, event, index); |
bee91169 | 836 | |
c6841592 HS |
837 | /* Check parameters */ |
838 | if (!num_events || !event) | |
839 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
32f4b2f8 HS |
840 | /* Check TPL */ |
841 | if (efi_tpl != TPL_APPLICATION) | |
842 | return EFI_EXIT(EFI_UNSUPPORTED); | |
c6841592 | 843 | for (i = 0; i < num_events; ++i) { |
43bce442 HS |
844 | if (efi_is_event(event[i]) != EFI_SUCCESS) |
845 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
c6841592 HS |
846 | if (!event[i]->type || event[i]->type & EVT_NOTIFY_SIGNAL) |
847 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
e190e897 | 848 | if (!event[i]->is_signaled) |
b095f3c8 | 849 | efi_queue_event(event[i], true); |
c6841592 HS |
850 | } |
851 | ||
852 | /* Wait for signal */ | |
853 | for (;;) { | |
854 | for (i = 0; i < num_events; ++i) { | |
e190e897 | 855 | if (event[i]->is_signaled) |
c6841592 HS |
856 | goto out; |
857 | } | |
858 | /* Allow events to occur. */ | |
859 | efi_timer_check(); | |
860 | } | |
861 | ||
862 | out: | |
863 | /* | |
864 | * Reset the signal which is passed to the caller to allow periodic | |
865 | * events to occur. | |
866 | */ | |
e190e897 | 867 | event[i]->is_signaled = false; |
c6841592 HS |
868 | if (index) |
869 | *index = i; | |
bee91169 AG |
870 | |
871 | return EFI_EXIT(EFI_SUCCESS); | |
872 | } | |
873 | ||
6b03cd10 | 874 | /** |
78a88f79 MS |
875 | * efi_signal_event_ext() - signal an EFI event |
876 | * @event: event to signal | |
332468f7 HS |
877 | * |
878 | * This function implements the SignalEvent service. | |
78a88f79 MS |
879 | * |
880 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
881 | * details. | |
332468f7 HS |
882 | * |
883 | * This functions sets the signaled state of the event and queues the | |
884 | * notification function for execution. | |
885 | * | |
78a88f79 | 886 | * Return: status code |
332468f7 | 887 | */ |
c6841592 | 888 | static efi_status_t EFIAPI efi_signal_event_ext(struct efi_event *event) |
bee91169 AG |
889 | { |
890 | EFI_ENTRY("%p", event); | |
43bce442 HS |
891 | if (efi_is_event(event) != EFI_SUCCESS) |
892 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
b095f3c8 | 893 | efi_signal_event(event, true); |
bee91169 AG |
894 | return EFI_EXIT(EFI_SUCCESS); |
895 | } | |
896 | ||
6b03cd10 | 897 | /** |
78a88f79 MS |
898 | * efi_close_event() - close an EFI event |
899 | * @event: event to close | |
332468f7 HS |
900 | * |
901 | * This function implements the CloseEvent service. | |
332468f7 | 902 | * |
78a88f79 MS |
903 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
904 | * details. | |
905 | * | |
906 | * Return: status code | |
332468f7 | 907 | */ |
2fd945fe | 908 | static efi_status_t EFIAPI efi_close_event(struct efi_event *event) |
bee91169 AG |
909 | { |
910 | EFI_ENTRY("%p", event); | |
43bce442 HS |
911 | if (efi_is_event(event) != EFI_SUCCESS) |
912 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
913 | list_del(&event->link); | |
914 | free(event); | |
915 | return EFI_EXIT(EFI_SUCCESS); | |
bee91169 AG |
916 | } |
917 | ||
6b03cd10 | 918 | /** |
78a88f79 MS |
919 | * efi_check_event() - check if an event is signaled |
920 | * @event: event to check | |
332468f7 HS |
921 | * |
922 | * This function implements the CheckEvent service. | |
332468f7 | 923 | * |
78a88f79 MS |
924 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
925 | * details. | |
926 | * | |
927 | * If an event is not signaled yet, the notification function is queued. The | |
928 | * signaled state is cleared. | |
332468f7 | 929 | * |
78a88f79 | 930 | * Return: status code |
332468f7 | 931 | */ |
2fd945fe | 932 | static efi_status_t EFIAPI efi_check_event(struct efi_event *event) |
bee91169 AG |
933 | { |
934 | EFI_ENTRY("%p", event); | |
c6841592 | 935 | efi_timer_check(); |
43bce442 HS |
936 | if (efi_is_event(event) != EFI_SUCCESS || |
937 | event->type & EVT_NOTIFY_SIGNAL) | |
938 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
939 | if (!event->is_signaled) | |
b095f3c8 | 940 | efi_queue_event(event, true); |
43bce442 HS |
941 | if (event->is_signaled) { |
942 | event->is_signaled = false; | |
943 | return EFI_EXIT(EFI_SUCCESS); | |
c6841592 | 944 | } |
43bce442 | 945 | return EFI_EXIT(EFI_NOT_READY); |
bee91169 AG |
946 | } |
947 | ||
6b03cd10 | 948 | /** |
78a88f79 MS |
949 | * efi_search_obj() - find the internal EFI object for a handle |
950 | * @handle: handle to find | |
7b9f8ad7 | 951 | * |
78a88f79 | 952 | * Return: EFI object |
7b9f8ad7 | 953 | */ |
2074f700 | 954 | struct efi_object *efi_search_obj(const efi_handle_t handle) |
7b9f8ad7 | 955 | { |
1b68153a | 956 | struct efi_object *efiobj; |
7b9f8ad7 | 957 | |
1b68153a | 958 | list_for_each_entry(efiobj, &efi_obj_list, link) { |
fae0118e | 959 | if (efiobj == handle) |
7b9f8ad7 HS |
960 | return efiobj; |
961 | } | |
962 | ||
963 | return NULL; | |
964 | } | |
965 | ||
6b03cd10 | 966 | /** |
78a88f79 MS |
967 | * efi_open_protocol_info_entry() - create open protocol info entry and add it |
968 | * to a protocol | |
969 | * @handler: handler of a protocol | |
fe1599da | 970 | * |
78a88f79 | 971 | * Return: open protocol info entry |
fe1599da HS |
972 | */ |
973 | static struct efi_open_protocol_info_entry *efi_create_open_info( | |
974 | struct efi_handler *handler) | |
975 | { | |
976 | struct efi_open_protocol_info_item *item; | |
977 | ||
978 | item = calloc(1, sizeof(struct efi_open_protocol_info_item)); | |
979 | if (!item) | |
980 | return NULL; | |
981 | /* Append the item to the open protocol info list. */ | |
982 | list_add_tail(&item->link, &handler->open_infos); | |
983 | ||
984 | return &item->info; | |
985 | } | |
986 | ||
6b03cd10 | 987 | /** |
78a88f79 MS |
988 | * efi_delete_open_info() - remove an open protocol info entry from a protocol |
989 | * @item: open protocol info entry to delete | |
fe1599da | 990 | * |
78a88f79 | 991 | * Return: status code |
fe1599da HS |
992 | */ |
993 | static efi_status_t efi_delete_open_info( | |
994 | struct efi_open_protocol_info_item *item) | |
995 | { | |
996 | list_del(&item->link); | |
997 | free(item); | |
998 | return EFI_SUCCESS; | |
999 | } | |
1000 | ||
6b03cd10 | 1001 | /** |
78a88f79 MS |
1002 | * efi_add_protocol() - install new protocol on a handle |
1003 | * @handle: handle on which the protocol shall be installed | |
1004 | * @protocol: GUID of the protocol to be installed | |
1005 | * @protocol_interface: interface of the protocol implementation | |
3f79a2b5 | 1006 | * |
78a88f79 | 1007 | * Return: status code |
3f79a2b5 | 1008 | */ |
2074f700 HS |
1009 | efi_status_t efi_add_protocol(const efi_handle_t handle, |
1010 | const efi_guid_t *protocol, | |
3f79a2b5 HS |
1011 | void *protocol_interface) |
1012 | { | |
1013 | struct efi_object *efiobj; | |
1014 | struct efi_handler *handler; | |
1015 | efi_status_t ret; | |
3f79a2b5 HS |
1016 | |
1017 | efiobj = efi_search_obj(handle); | |
1018 | if (!efiobj) | |
1019 | return EFI_INVALID_PARAMETER; | |
1020 | ret = efi_search_protocol(handle, protocol, NULL); | |
1021 | if (ret != EFI_NOT_FOUND) | |
1022 | return EFI_INVALID_PARAMETER; | |
1023 | handler = calloc(1, sizeof(struct efi_handler)); | |
1024 | if (!handler) | |
1025 | return EFI_OUT_OF_RESOURCES; | |
69fb6b1a HS |
1026 | handler->guid = protocol; |
1027 | handler->protocol_interface = protocol_interface; | |
fe1599da | 1028 | INIT_LIST_HEAD(&handler->open_infos); |
69fb6b1a | 1029 | list_add_tail(&handler->link, &efiobj->protocols); |
d5504144 HS |
1030 | if (!guidcmp(&efi_guid_device_path, protocol)) |
1031 | EFI_PRINT("installed device path '%pD'\n", protocol_interface); | |
69fb6b1a | 1032 | return EFI_SUCCESS; |
3f79a2b5 HS |
1033 | } |
1034 | ||
6b03cd10 | 1035 | /** |
78a88f79 MS |
1036 | * efi_install_protocol_interface() - install protocol interface |
1037 | * @handle: handle on which the protocol shall be installed | |
1038 | * @protocol: GUID of the protocol to be installed | |
1039 | * @protocol_interface_type: type of the interface to be installed, | |
1040 | * always EFI_NATIVE_INTERFACE | |
1041 | * @protocol_interface: interface of the protocol implementation | |
332468f7 | 1042 | * |
1760ef57 | 1043 | * This function implements the InstallProtocolInterface service. |
332468f7 | 1044 | * |
78a88f79 MS |
1045 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1046 | * details. | |
1047 | * | |
1048 | * Return: status code | |
332468f7 | 1049 | */ |
1760ef57 | 1050 | static efi_status_t EFIAPI efi_install_protocol_interface( |
faea1041 | 1051 | efi_handle_t *handle, const efi_guid_t *protocol, |
1760ef57 | 1052 | int protocol_interface_type, void *protocol_interface) |
bee91169 | 1053 | { |
e0549f8a HS |
1054 | efi_status_t r; |
1055 | ||
1760ef57 HS |
1056 | EFI_ENTRY("%p, %pUl, %d, %p", handle, protocol, protocol_interface_type, |
1057 | protocol_interface); | |
1058 | ||
e0549f8a HS |
1059 | if (!handle || !protocol || |
1060 | protocol_interface_type != EFI_NATIVE_INTERFACE) { | |
1061 | r = EFI_INVALID_PARAMETER; | |
1062 | goto out; | |
1063 | } | |
1064 | ||
1065 | /* Create new handle if requested. */ | |
1066 | if (!*handle) { | |
3cc6e3fe HS |
1067 | r = efi_create_handle(handle); |
1068 | if (r != EFI_SUCCESS) | |
1069 | goto out; | |
af1408e0 HS |
1070 | debug("%sEFI: new handle %p\n", indent_string(nesting_level), |
1071 | *handle); | |
1072 | } else { | |
1073 | debug("%sEFI: handle %p\n", indent_string(nesting_level), | |
1074 | *handle); | |
e0549f8a | 1075 | } |
1202530d HS |
1076 | /* Add new protocol */ |
1077 | r = efi_add_protocol(*handle, protocol, protocol_interface); | |
e0549f8a | 1078 | out: |
1760ef57 | 1079 | return EFI_EXIT(r); |
bee91169 | 1080 | } |
e0549f8a | 1081 | |
6b03cd10 | 1082 | /** |
78a88f79 | 1083 | * efi_get_drivers() - get all drivers associated to a controller |
fae0118e | 1084 | * @handle: handle of the controller |
b72aaa87 | 1085 | * @protocol: protocol GUID (optional) |
78a88f79 MS |
1086 | * @number_of_drivers: number of child controllers |
1087 | * @driver_handle_buffer: handles of the the drivers | |
6b03cd10 | 1088 | * |
3f9b0042 HS |
1089 | * The allocated buffer has to be freed with free(). |
1090 | * | |
78a88f79 | 1091 | * Return: status code |
3f9b0042 | 1092 | */ |
fae0118e | 1093 | static efi_status_t efi_get_drivers(efi_handle_t handle, |
3f9b0042 HS |
1094 | const efi_guid_t *protocol, |
1095 | efi_uintn_t *number_of_drivers, | |
1096 | efi_handle_t **driver_handle_buffer) | |
1097 | { | |
1098 | struct efi_handler *handler; | |
1099 | struct efi_open_protocol_info_item *item; | |
1100 | efi_uintn_t count = 0, i; | |
1101 | bool duplicate; | |
1102 | ||
1103 | /* Count all driver associations */ | |
fae0118e | 1104 | list_for_each_entry(handler, &handle->protocols, link) { |
3f9b0042 HS |
1105 | if (protocol && guidcmp(handler->guid, protocol)) |
1106 | continue; | |
1107 | list_for_each_entry(item, &handler->open_infos, link) { | |
1108 | if (item->info.attributes & | |
1109 | EFI_OPEN_PROTOCOL_BY_DRIVER) | |
1110 | ++count; | |
1111 | } | |
1112 | } | |
1113 | /* | |
1114 | * Create buffer. In case of duplicate driver assignments the buffer | |
1115 | * will be too large. But that does not harm. | |
1116 | */ | |
1117 | *number_of_drivers = 0; | |
1118 | *driver_handle_buffer = calloc(count, sizeof(efi_handle_t)); | |
1119 | if (!*driver_handle_buffer) | |
1120 | return EFI_OUT_OF_RESOURCES; | |
1121 | /* Collect unique driver handles */ | |
fae0118e | 1122 | list_for_each_entry(handler, &handle->protocols, link) { |
3f9b0042 HS |
1123 | if (protocol && guidcmp(handler->guid, protocol)) |
1124 | continue; | |
1125 | list_for_each_entry(item, &handler->open_infos, link) { | |
1126 | if (item->info.attributes & | |
1127 | EFI_OPEN_PROTOCOL_BY_DRIVER) { | |
1128 | /* Check this is a new driver */ | |
1129 | duplicate = false; | |
1130 | for (i = 0; i < *number_of_drivers; ++i) { | |
1131 | if ((*driver_handle_buffer)[i] == | |
1132 | item->info.agent_handle) | |
1133 | duplicate = true; | |
1134 | } | |
1135 | /* Copy handle to buffer */ | |
1136 | if (!duplicate) { | |
1137 | i = (*number_of_drivers)++; | |
1138 | (*driver_handle_buffer)[i] = | |
1139 | item->info.agent_handle; | |
1140 | } | |
1141 | } | |
1142 | } | |
1143 | } | |
1144 | return EFI_SUCCESS; | |
1145 | } | |
1146 | ||
6b03cd10 | 1147 | /** |
78a88f79 | 1148 | * efi_disconnect_all_drivers() - disconnect all drivers from a controller |
fae0118e | 1149 | * @handle: handle of the controller |
b72aaa87 | 1150 | * @protocol: protocol GUID (optional) |
78a88f79 | 1151 | * @child_handle: handle of the child to destroy |
3f9b0042 HS |
1152 | * |
1153 | * This function implements the DisconnectController service. | |
3f9b0042 | 1154 | * |
78a88f79 MS |
1155 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1156 | * details. | |
1157 | * | |
1158 | * Return: status code | |
3f9b0042 | 1159 | */ |
fae0118e HS |
1160 | static efi_status_t efi_disconnect_all_drivers |
1161 | (efi_handle_t handle, | |
1162 | const efi_guid_t *protocol, | |
1163 | efi_handle_t child_handle) | |
3f9b0042 HS |
1164 | { |
1165 | efi_uintn_t number_of_drivers; | |
1166 | efi_handle_t *driver_handle_buffer; | |
1167 | efi_status_t r, ret; | |
1168 | ||
fae0118e | 1169 | ret = efi_get_drivers(handle, protocol, &number_of_drivers, |
3f9b0042 HS |
1170 | &driver_handle_buffer); |
1171 | if (ret != EFI_SUCCESS) | |
1172 | return ret; | |
1173 | ||
1174 | ret = EFI_NOT_FOUND; | |
1175 | while (number_of_drivers) { | |
1176 | r = EFI_CALL(efi_disconnect_controller( | |
fae0118e | 1177 | handle, |
3f9b0042 HS |
1178 | driver_handle_buffer[--number_of_drivers], |
1179 | child_handle)); | |
1180 | if (r == EFI_SUCCESS) | |
1181 | ret = r; | |
1182 | } | |
1183 | free(driver_handle_buffer); | |
1184 | return ret; | |
1185 | } | |
1186 | ||
6b03cd10 | 1187 | /** |
9b47f13b HS |
1188 | * efi_uninstall_protocol() - uninstall protocol interface |
1189 | * | |
78a88f79 MS |
1190 | * @handle: handle from which the protocol shall be removed |
1191 | * @protocol: GUID of the protocol to be removed | |
1192 | * @protocol_interface: interface to be removed | |
332468f7 | 1193 | * |
9b47f13b | 1194 | * This function DOES NOT delete a handle without installed protocol. |
78a88f79 MS |
1195 | * |
1196 | * Return: status code | |
332468f7 | 1197 | */ |
9b47f13b HS |
1198 | static efi_status_t efi_uninstall_protocol |
1199 | (efi_handle_t handle, const efi_guid_t *protocol, | |
1200 | void *protocol_interface) | |
bee91169 | 1201 | { |
ad97373b | 1202 | struct efi_object *efiobj; |
5810511d | 1203 | struct efi_handler *handler; |
ad97373b HS |
1204 | struct efi_open_protocol_info_item *item; |
1205 | struct efi_open_protocol_info_item *pos; | |
5810511d | 1206 | efi_status_t r; |
4b6ed0d7 | 1207 | |
ad97373b HS |
1208 | /* Check handle */ |
1209 | efiobj = efi_search_obj(handle); | |
1210 | if (!efiobj) { | |
4b6ed0d7 HS |
1211 | r = EFI_INVALID_PARAMETER; |
1212 | goto out; | |
1213 | } | |
5810511d HS |
1214 | /* Find the protocol on the handle */ |
1215 | r = efi_search_protocol(handle, protocol, &handler); | |
1216 | if (r != EFI_SUCCESS) | |
1217 | goto out; | |
ad97373b HS |
1218 | /* Disconnect controllers */ |
1219 | efi_disconnect_all_drivers(efiobj, protocol, NULL); | |
1220 | if (!list_empty(&handler->open_infos)) { | |
5810511d | 1221 | r = EFI_ACCESS_DENIED; |
ad97373b HS |
1222 | goto out; |
1223 | } | |
1224 | /* Close protocol */ | |
1225 | list_for_each_entry_safe(item, pos, &handler->open_infos, link) { | |
1226 | if (item->info.attributes == | |
1227 | EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL || | |
1228 | item->info.attributes == EFI_OPEN_PROTOCOL_GET_PROTOCOL || | |
1229 | item->info.attributes == EFI_OPEN_PROTOCOL_TEST_PROTOCOL) | |
1230 | list_del(&item->link); | |
1231 | } | |
1232 | if (!list_empty(&handler->open_infos)) { | |
1233 | r = EFI_ACCESS_DENIED; | |
1234 | goto out; | |
4b6ed0d7 | 1235 | } |
ad97373b | 1236 | r = efi_remove_protocol(handle, protocol, protocol_interface); |
4b6ed0d7 | 1237 | out: |
9b47f13b HS |
1238 | return r; |
1239 | } | |
1240 | ||
1241 | /** | |
1242 | * efi_uninstall_protocol_interface() - uninstall protocol interface | |
1243 | * @handle: handle from which the protocol shall be removed | |
1244 | * @protocol: GUID of the protocol to be removed | |
1245 | * @protocol_interface: interface to be removed | |
1246 | * | |
1247 | * This function implements the UninstallProtocolInterface service. | |
1248 | * | |
1249 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
1250 | * details. | |
1251 | * | |
1252 | * Return: status code | |
1253 | */ | |
1254 | static efi_status_t EFIAPI efi_uninstall_protocol_interface | |
1255 | (efi_handle_t handle, const efi_guid_t *protocol, | |
1256 | void *protocol_interface) | |
1257 | { | |
1258 | efi_status_t ret; | |
1259 | ||
1260 | EFI_ENTRY("%p, %pUl, %p", handle, protocol, protocol_interface); | |
1261 | ||
1262 | ret = efi_uninstall_protocol(handle, protocol, protocol_interface); | |
1263 | if (ret != EFI_SUCCESS) | |
1264 | goto out; | |
1265 | ||
1266 | /* If the last protocol has been removed, delete the handle. */ | |
1267 | if (list_empty(&handle->protocols)) { | |
1268 | list_del(&handle->link); | |
1269 | free(handle); | |
1270 | } | |
1271 | out: | |
1272 | return EFI_EXIT(ret); | |
bee91169 AG |
1273 | } |
1274 | ||
6b03cd10 | 1275 | /** |
78a88f79 MS |
1276 | * efi_register_protocol_notify() - register an event for notification when a |
1277 | * protocol is installed. | |
1278 | * @protocol: GUID of the protocol whose installation shall be notified | |
1279 | * @event: event to be signaled upon installation of the protocol | |
1280 | * @registration: key for retrieving the registration information | |
332468f7 HS |
1281 | * |
1282 | * This function implements the RegisterProtocolNotify service. | |
1283 | * See the Unified Extensible Firmware Interface (UEFI) specification | |
1284 | * for details. | |
1285 | * | |
78a88f79 | 1286 | * Return: status code |
332468f7 | 1287 | */ |
5a9682d0 HS |
1288 | static efi_status_t EFIAPI efi_register_protocol_notify( |
1289 | const efi_guid_t *protocol, | |
1290 | struct efi_event *event, | |
1291 | void **registration) | |
bee91169 | 1292 | { |
778e6af8 | 1293 | EFI_ENTRY("%pUl, %p, %p", protocol, event, registration); |
bee91169 AG |
1294 | return EFI_EXIT(EFI_OUT_OF_RESOURCES); |
1295 | } | |
1296 | ||
6b03cd10 | 1297 | /** |
78a88f79 MS |
1298 | * efi_search() - determine if an EFI handle implements a protocol |
1299 | * @search_type: selection criterion | |
1300 | * @protocol: GUID of the protocol | |
1301 | * @search_key: registration key | |
fae0118e | 1302 | * @handle: handle |
332468f7 HS |
1303 | * |
1304 | * See the documentation of the LocateHandle service in the UEFI specification. | |
1305 | * | |
78a88f79 | 1306 | * Return: 0 if the handle implements the protocol |
332468f7 | 1307 | */ |
bee91169 | 1308 | static int efi_search(enum efi_locate_search_type search_type, |
5a9682d0 | 1309 | const efi_guid_t *protocol, void *search_key, |
fae0118e | 1310 | efi_handle_t handle) |
bee91169 | 1311 | { |
42cf1242 | 1312 | efi_status_t ret; |
bee91169 AG |
1313 | |
1314 | switch (search_type) { | |
9f0770ff | 1315 | case ALL_HANDLES: |
bee91169 | 1316 | return 0; |
9f0770ff | 1317 | case BY_REGISTER_NOTIFY: |
42cf1242 | 1318 | /* TODO: RegisterProtocolNotify is not implemented yet */ |
bee91169 | 1319 | return -1; |
9f0770ff | 1320 | case BY_PROTOCOL: |
fae0118e | 1321 | ret = efi_search_protocol(handle, protocol, NULL); |
42cf1242 HS |
1322 | return (ret != EFI_SUCCESS); |
1323 | default: | |
1324 | /* Invalid search type */ | |
bee91169 AG |
1325 | return -1; |
1326 | } | |
bee91169 AG |
1327 | } |
1328 | ||
6b03cd10 | 1329 | /** |
78a88f79 MS |
1330 | * efi_locate_handle() - locate handles implementing a protocol |
1331 | * @search_type: selection criterion | |
1332 | * @protocol: GUID of the protocol | |
1333 | * @search_key: registration key | |
1334 | * @buffer_size: size of the buffer to receive the handles in bytes | |
1335 | * @buffer: buffer to receive the relevant handles | |
332468f7 HS |
1336 | * |
1337 | * This function is meant for U-Boot internal calls. For the API implementation | |
1338 | * of the LocateHandle service see efi_locate_handle_ext. | |
1339 | * | |
78a88f79 | 1340 | * Return: status code |
332468f7 | 1341 | */ |
ebf199b9 | 1342 | static efi_status_t efi_locate_handle( |
bee91169 | 1343 | enum efi_locate_search_type search_type, |
5a9682d0 | 1344 | const efi_guid_t *protocol, void *search_key, |
f5a2a938 | 1345 | efi_uintn_t *buffer_size, efi_handle_t *buffer) |
bee91169 | 1346 | { |
caf864e4 | 1347 | struct efi_object *efiobj; |
f5a2a938 | 1348 | efi_uintn_t size = 0; |
bee91169 | 1349 | |
caf864e4 HS |
1350 | /* Check parameters */ |
1351 | switch (search_type) { | |
1352 | case ALL_HANDLES: | |
1353 | break; | |
1354 | case BY_REGISTER_NOTIFY: | |
1355 | if (!search_key) | |
1356 | return EFI_INVALID_PARAMETER; | |
1357 | /* RegisterProtocolNotify is not implemented yet */ | |
1358 | return EFI_UNSUPPORTED; | |
1359 | case BY_PROTOCOL: | |
1360 | if (!protocol) | |
1361 | return EFI_INVALID_PARAMETER; | |
1362 | break; | |
1363 | default: | |
1364 | return EFI_INVALID_PARAMETER; | |
1365 | } | |
1366 | ||
bee91169 | 1367 | /* Count how much space we need */ |
caf864e4 HS |
1368 | list_for_each_entry(efiobj, &efi_obj_list, link) { |
1369 | if (!efi_search(search_type, protocol, search_key, efiobj)) | |
ab9efa97 | 1370 | size += sizeof(void *); |
bee91169 AG |
1371 | } |
1372 | ||
8dfb5e6e HS |
1373 | if (size == 0) |
1374 | return EFI_NOT_FOUND; | |
1375 | ||
1376 | if (!buffer_size) | |
1377 | return EFI_INVALID_PARAMETER; | |
1378 | ||
bee91169 AG |
1379 | if (*buffer_size < size) { |
1380 | *buffer_size = size; | |
26329584 | 1381 | return EFI_BUFFER_TOO_SMALL; |
bee91169 AG |
1382 | } |
1383 | ||
796a78cb | 1384 | *buffer_size = size; |
8dfb5e6e HS |
1385 | |
1386 | /* The buffer size is sufficient but there is not buffer */ | |
1387 | if (!buffer) | |
1388 | return EFI_INVALID_PARAMETER; | |
796a78cb | 1389 | |
bee91169 | 1390 | /* Then fill the array */ |
caf864e4 HS |
1391 | list_for_each_entry(efiobj, &efi_obj_list, link) { |
1392 | if (!efi_search(search_type, protocol, search_key, efiobj)) | |
fae0118e | 1393 | *buffer++ = efiobj; |
bee91169 AG |
1394 | } |
1395 | ||
26329584 HS |
1396 | return EFI_SUCCESS; |
1397 | } | |
1398 | ||
6b03cd10 | 1399 | /** |
78a88f79 MS |
1400 | * efi_locate_handle_ext() - locate handles implementing a protocol. |
1401 | * @search_type: selection criterion | |
1402 | * @protocol: GUID of the protocol | |
1403 | * @search_key: registration key | |
1404 | * @buffer_size: size of the buffer to receive the handles in bytes | |
1405 | * @buffer: buffer to receive the relevant handles | |
332468f7 HS |
1406 | * |
1407 | * This function implements the LocateHandle service. | |
332468f7 | 1408 | * |
78a88f79 MS |
1409 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1410 | * details. | |
1411 | * | |
1412 | * Return: 0 if the handle implements the protocol | |
332468f7 | 1413 | */ |
26329584 HS |
1414 | static efi_status_t EFIAPI efi_locate_handle_ext( |
1415 | enum efi_locate_search_type search_type, | |
5a9682d0 | 1416 | const efi_guid_t *protocol, void *search_key, |
f5a2a938 | 1417 | efi_uintn_t *buffer_size, efi_handle_t *buffer) |
26329584 | 1418 | { |
778e6af8 | 1419 | EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key, |
26329584 HS |
1420 | buffer_size, buffer); |
1421 | ||
1422 | return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key, | |
1423 | buffer_size, buffer)); | |
bee91169 AG |
1424 | } |
1425 | ||
6b03cd10 | 1426 | /** |
78a88f79 MS |
1427 | * efi_remove_configuration_table() - collapses configuration table entries, |
1428 | * removing index i | |
6b03cd10 | 1429 | * |
78a88f79 | 1430 | * @i: index of the table entry to be removed |
6b03cd10 | 1431 | */ |
d98cdf6a AG |
1432 | static void efi_remove_configuration_table(int i) |
1433 | { | |
4182a129 HS |
1434 | struct efi_configuration_table *this = &systab.tables[i]; |
1435 | struct efi_configuration_table *next = &systab.tables[i + 1]; | |
1436 | struct efi_configuration_table *end = &systab.tables[systab.nr_tables]; | |
d98cdf6a AG |
1437 | |
1438 | memmove(this, next, (ulong)end - (ulong)next); | |
1439 | systab.nr_tables--; | |
1440 | } | |
1441 | ||
6b03cd10 | 1442 | /** |
78a88f79 MS |
1443 | * efi_install_configuration_table() - adds, updates, or removes a |
1444 | * configuration table | |
1445 | * @guid: GUID of the installed table | |
1446 | * @table: table to be installed | |
332468f7 HS |
1447 | * |
1448 | * This function is used for internal calls. For the API implementation of the | |
1449 | * InstallConfigurationTable service see efi_install_configuration_table_ext. | |
1450 | * | |
78a88f79 | 1451 | * Return: status code |
332468f7 | 1452 | */ |
ab9efa97 HS |
1453 | efi_status_t efi_install_configuration_table(const efi_guid_t *guid, |
1454 | void *table) | |
bee91169 | 1455 | { |
b095f3c8 | 1456 | struct efi_event *evt; |
bee91169 AG |
1457 | int i; |
1458 | ||
eb68b4ef HS |
1459 | if (!guid) |
1460 | return EFI_INVALID_PARAMETER; | |
1461 | ||
b72aaa87 | 1462 | /* Check for GUID override */ |
bee91169 | 1463 | for (i = 0; i < systab.nr_tables; i++) { |
4182a129 | 1464 | if (!guidcmp(guid, &systab.tables[i].guid)) { |
d98cdf6a | 1465 | if (table) |
4182a129 | 1466 | systab.tables[i].table = table; |
d98cdf6a AG |
1467 | else |
1468 | efi_remove_configuration_table(i); | |
b095f3c8 | 1469 | goto out; |
bee91169 AG |
1470 | } |
1471 | } | |
1472 | ||
d98cdf6a AG |
1473 | if (!table) |
1474 | return EFI_NOT_FOUND; | |
1475 | ||
bee91169 | 1476 | /* No override, check for overflow */ |
4182a129 | 1477 | if (i >= EFI_MAX_CONFIGURATION_TABLES) |
488bf12d | 1478 | return EFI_OUT_OF_RESOURCES; |
bee91169 AG |
1479 | |
1480 | /* Add a new entry */ | |
4182a129 HS |
1481 | memcpy(&systab.tables[i].guid, guid, sizeof(*guid)); |
1482 | systab.tables[i].table = table; | |
aba5e919 | 1483 | systab.nr_tables = i + 1; |
bee91169 | 1484 | |
b095f3c8 | 1485 | out: |
b72aaa87 | 1486 | /* systab.nr_tables may have changed. So we need to update the CRC32 */ |
55d8ee3b HS |
1487 | efi_update_table_header_crc32(&systab.hdr); |
1488 | ||
b095f3c8 HS |
1489 | /* Notify that the configuration table was changed */ |
1490 | list_for_each_entry(evt, &efi_events, link) { | |
1491 | if (evt->group && !guidcmp(evt->group, guid)) { | |
1492 | efi_signal_event(evt, false); | |
1493 | break; | |
1494 | } | |
1495 | } | |
1496 | ||
488bf12d AG |
1497 | return EFI_SUCCESS; |
1498 | } | |
1499 | ||
6b03cd10 | 1500 | /** |
78a88f79 MS |
1501 | * efi_install_configuration_table_ex() - Adds, updates, or removes a |
1502 | * configuration table. | |
1503 | * @guid: GUID of the installed table | |
1504 | * @table: table to be installed | |
332468f7 HS |
1505 | * |
1506 | * This function implements the InstallConfigurationTable service. | |
332468f7 | 1507 | * |
78a88f79 MS |
1508 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1509 | * details. | |
1510 | * | |
1511 | * Return: status code | |
332468f7 | 1512 | */ |
488bf12d AG |
1513 | static efi_status_t EFIAPI efi_install_configuration_table_ext(efi_guid_t *guid, |
1514 | void *table) | |
1515 | { | |
778e6af8 | 1516 | EFI_ENTRY("%pUl, %p", guid, table); |
488bf12d | 1517 | return EFI_EXIT(efi_install_configuration_table(guid, table)); |
bee91169 AG |
1518 | } |
1519 | ||
6b03cd10 | 1520 | /** |
78a88f79 | 1521 | * efi_setup_loaded_image() - initialize a loaded image |
6b03cd10 HS |
1522 | * |
1523 | * Initialize a loaded_image_info and loaded_image_info object with correct | |
95c5553e | 1524 | * protocols, boot-device, etc. |
332468f7 | 1525 | * |
16112f9f HS |
1526 | * In case of an error *handle_ptr and *info_ptr are set to NULL and an error |
1527 | * code is returned. | |
1528 | * | |
1529 | * @device_path: device path of the loaded image | |
1530 | * @file_path: file path of the loaded image | |
1531 | * @handle_ptr: handle of the loaded image | |
1532 | * @info_ptr: loaded image protocol | |
1533 | * Return: status code | |
95c5553e | 1534 | */ |
c982874e HS |
1535 | efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, |
1536 | struct efi_device_path *file_path, | |
1537 | struct efi_loaded_image_obj **handle_ptr, | |
1538 | struct efi_loaded_image **info_ptr) | |
95c5553e | 1539 | { |
48b66230 | 1540 | efi_status_t ret; |
16112f9f HS |
1541 | struct efi_loaded_image *info = NULL; |
1542 | struct efi_loaded_image_obj *obj = NULL; | |
bc8fc328 | 1543 | struct efi_device_path *dp; |
16112f9f HS |
1544 | |
1545 | /* In case of EFI_OUT_OF_RESOURCES avoid illegal free by caller. */ | |
1546 | *handle_ptr = NULL; | |
1547 | *info_ptr = NULL; | |
c982874e HS |
1548 | |
1549 | info = calloc(1, sizeof(*info)); | |
1550 | if (!info) | |
1551 | return EFI_OUT_OF_RESOURCES; | |
1552 | obj = calloc(1, sizeof(*obj)); | |
1553 | if (!obj) { | |
1554 | free(info); | |
1555 | return EFI_OUT_OF_RESOURCES; | |
1556 | } | |
cd73aba6 | 1557 | obj->header.type = EFI_OBJECT_TYPE_LOADED_IMAGE; |
48b66230 | 1558 | |
44549d62 | 1559 | /* Add internal object to object list */ |
d39646a3 | 1560 | efi_add_handle(&obj->header); |
c982874e | 1561 | |
95147313 | 1562 | info->revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION; |
48b66230 | 1563 | info->file_path = file_path; |
7e1effce | 1564 | info->system_table = &systab; |
48b66230 | 1565 | |
7df5af6f HS |
1566 | if (device_path) { |
1567 | info->device_handle = efi_dp_find_obj(device_path, NULL); | |
bc8fc328 AT |
1568 | |
1569 | dp = efi_dp_append(device_path, file_path); | |
1570 | if (!dp) { | |
1571 | ret = EFI_OUT_OF_RESOURCES; | |
7df5af6f | 1572 | goto failure; |
bc8fc328 AT |
1573 | } |
1574 | } else { | |
1575 | dp = NULL; | |
7df5af6f | 1576 | } |
bc8fc328 AT |
1577 | ret = efi_add_protocol(&obj->header, |
1578 | &efi_guid_loaded_image_device_path, dp); | |
1579 | if (ret != EFI_SUCCESS) | |
1580 | goto failure; | |
95c5553e RC |
1581 | |
1582 | /* | |
1583 | * When asking for the loaded_image interface, just | |
1584 | * return handle which points to loaded_image_info | |
1585 | */ | |
d39646a3 | 1586 | ret = efi_add_protocol(&obj->header, |
c982874e | 1587 | &efi_guid_loaded_image, info); |
48b66230 HS |
1588 | if (ret != EFI_SUCCESS) |
1589 | goto failure; | |
95c5553e | 1590 | |
d5974af7 HS |
1591 | *info_ptr = info; |
1592 | *handle_ptr = obj; | |
16112f9f | 1593 | |
56d92888 | 1594 | return ret; |
48b66230 HS |
1595 | failure: |
1596 | printf("ERROR: Failure to install protocols for loaded image\n"); | |
16112f9f HS |
1597 | efi_delete_handle(&obj->header); |
1598 | free(info); | |
56d92888 | 1599 | return ret; |
95c5553e RC |
1600 | } |
1601 | ||
6b03cd10 | 1602 | /** |
78a88f79 | 1603 | * efi_load_image_from_path() - load an image using a file path |
332468f7 | 1604 | * |
0e18f584 HS |
1605 | * Read a file into a buffer allocated as EFI_BOOT_SERVICES_DATA. It is the |
1606 | * callers obligation to update the memory type as needed. | |
1607 | * | |
1608 | * @file_path: the path of the image to load | |
1609 | * @buffer: buffer containing the loaded image | |
1610 | * @size: size of the loaded image | |
1611 | * Return: status code | |
332468f7 | 1612 | */ |
6b95b38c | 1613 | static |
9975fe96 | 1614 | efi_status_t efi_load_image_from_path(struct efi_device_path *file_path, |
0e18f584 | 1615 | void **buffer, efi_uintn_t *size) |
838ee4b4 RC |
1616 | { |
1617 | struct efi_file_info *info = NULL; | |
1618 | struct efi_file_handle *f; | |
1619 | static efi_status_t ret; | |
0e18f584 | 1620 | u64 addr; |
b6dd5777 | 1621 | efi_uintn_t bs; |
838ee4b4 | 1622 | |
0e18f584 HS |
1623 | /* In case of failure nothing is returned */ |
1624 | *buffer = NULL; | |
1625 | *size = 0; | |
1626 | ||
1627 | /* Open file */ | |
838ee4b4 RC |
1628 | f = efi_file_from_path(file_path); |
1629 | if (!f) | |
1630 | return EFI_DEVICE_ERROR; | |
1631 | ||
0e18f584 | 1632 | /* Get file size */ |
838ee4b4 RC |
1633 | bs = 0; |
1634 | EFI_CALL(ret = f->getinfo(f, (efi_guid_t *)&efi_file_info_guid, | |
1635 | &bs, info)); | |
0e18f584 HS |
1636 | if (ret != EFI_BUFFER_TOO_SMALL) { |
1637 | ret = EFI_DEVICE_ERROR; | |
838ee4b4 | 1638 | goto error; |
0e18f584 | 1639 | } |
838ee4b4 | 1640 | |
0e18f584 HS |
1641 | info = malloc(bs); |
1642 | EFI_CALL(ret = f->getinfo(f, (efi_guid_t *)&efi_file_info_guid, &bs, | |
1643 | info)); | |
1644 | if (ret != EFI_SUCCESS) | |
838ee4b4 RC |
1645 | goto error; |
1646 | ||
0e18f584 HS |
1647 | /* |
1648 | * When reading the file we do not yet know if it contains an | |
1649 | * application, a boottime driver, or a runtime driver. So here we | |
1650 | * allocate a buffer as EFI_BOOT_SERVICES_DATA. The caller has to | |
1651 | * update the reservation according to the image type. | |
1652 | */ | |
b6dd5777 | 1653 | bs = info->file_size; |
0e18f584 HS |
1654 | ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, |
1655 | EFI_BOOT_SERVICES_DATA, | |
1656 | efi_size_in_pages(bs), &addr); | |
838ee4b4 | 1657 | if (ret != EFI_SUCCESS) { |
0e18f584 HS |
1658 | ret = EFI_OUT_OF_RESOURCES; |
1659 | goto error; | |
838ee4b4 RC |
1660 | } |
1661 | ||
0e18f584 HS |
1662 | /* Read file */ |
1663 | EFI_CALL(ret = f->read(f, &bs, (void *)(uintptr_t)addr)); | |
1664 | if (ret != EFI_SUCCESS) | |
1665 | efi_free_pages(addr, efi_size_in_pages(bs)); | |
1666 | *buffer = (void *)(uintptr_t)addr; | |
1667 | *size = bs; | |
1668 | error: | |
1669 | EFI_CALL(f->close(f)); | |
1670 | free(info); | |
838ee4b4 RC |
1671 | return ret; |
1672 | } | |
1673 | ||
6b03cd10 | 1674 | /** |
78a88f79 MS |
1675 | * efi_load_image() - load an EFI image into memory |
1676 | * @boot_policy: true for request originating from the boot manager | |
1677 | * @parent_image: the caller's image handle | |
1678 | * @file_path: the path of the image to load | |
1679 | * @source_buffer: memory location from which the image is installed | |
1680 | * @source_size: size of the memory area from which the image is installed | |
1681 | * @image_handle: handle for the newly installed image | |
332468f7 HS |
1682 | * |
1683 | * This function implements the LoadImage service. | |
78a88f79 | 1684 | * |
332468f7 HS |
1685 | * See the Unified Extensible Firmware Interface (UEFI) specification |
1686 | * for details. | |
1687 | * | |
78a88f79 | 1688 | * Return: status code |
332468f7 | 1689 | */ |
d7e0b010 AT |
1690 | efi_status_t EFIAPI efi_load_image(bool boot_policy, |
1691 | efi_handle_t parent_image, | |
1692 | struct efi_device_path *file_path, | |
1693 | void *source_buffer, | |
1694 | efi_uintn_t source_size, | |
1695 | efi_handle_t *image_handle) | |
bee91169 | 1696 | { |
0e18f584 | 1697 | struct efi_device_path *dp, *fp; |
1c3b2f4a | 1698 | struct efi_loaded_image *info = NULL; |
c982874e HS |
1699 | struct efi_loaded_image_obj **image_obj = |
1700 | (struct efi_loaded_image_obj **)image_handle; | |
b9b17598 | 1701 | efi_status_t ret; |
b0c3c346 | 1702 | void *dest_buffer; |
bee91169 | 1703 | |
7fb96a10 | 1704 | EFI_ENTRY("%d, %p, %pD, %p, %zd, %p", boot_policy, parent_image, |
bee91169 | 1705 | file_path, source_buffer, source_size, image_handle); |
838ee4b4 | 1706 | |
28a4fd46 HS |
1707 | if (!image_handle || !parent_image) { |
1708 | ret = EFI_INVALID_PARAMETER; | |
1709 | goto error; | |
1710 | } | |
1711 | ||
1712 | if (!source_buffer && !file_path) { | |
1713 | ret = EFI_NOT_FOUND; | |
1714 | goto error; | |
1715 | } | |
1716 | ||
838ee4b4 | 1717 | if (!source_buffer) { |
b0c3c346 | 1718 | ret = efi_load_image_from_path(file_path, &dest_buffer, |
0e18f584 | 1719 | &source_size); |
b9b17598 | 1720 | if (ret != EFI_SUCCESS) |
0e18f584 | 1721 | goto error; |
838ee4b4 | 1722 | } else { |
b0c3c346 | 1723 | dest_buffer = source_buffer; |
838ee4b4 | 1724 | } |
1e15a9cb HS |
1725 | /* split file_path which contains both the device and file parts */ |
1726 | efi_dp_split_file_path(file_path, &dp, &fp); | |
0e18f584 | 1727 | ret = efi_setup_loaded_image(dp, fp, image_obj, &info); |
b0c3c346 HS |
1728 | if (ret == EFI_SUCCESS) |
1729 | ret = efi_load_pe(*image_obj, dest_buffer, info); | |
1730 | if (!source_buffer) | |
1731 | /* Release buffer to which file was loaded */ | |
1732 | efi_free_pages((uintptr_t)dest_buffer, | |
1733 | efi_size_in_pages(source_size)); | |
1734 | if (ret == EFI_SUCCESS) { | |
1735 | info->system_table = &systab; | |
1736 | info->parent_handle = parent_image; | |
1737 | } else { | |
1738 | /* The image is invalid. Release all associated resources. */ | |
1739 | efi_delete_handle(*image_handle); | |
1740 | *image_handle = NULL; | |
1741 | free(info); | |
1742 | } | |
28a4fd46 | 1743 | error: |
b9b17598 | 1744 | return EFI_EXIT(ret); |
bee91169 AG |
1745 | } |
1746 | ||
f31239ac AG |
1747 | /** |
1748 | * efi_exit_caches() - fix up caches for EFI payloads if necessary | |
1749 | */ | |
1750 | static void efi_exit_caches(void) | |
1751 | { | |
1752 | #if defined(CONFIG_ARM) && !defined(CONFIG_ARM64) | |
1753 | /* | |
1754 | * Grub on 32bit ARM needs to have caches disabled before jumping into | |
1755 | * a zImage, but does not know of all cache layers. Give it a hand. | |
1756 | */ | |
1757 | if (efi_is_direct_boot) | |
1758 | cleanup_before_linux(); | |
1759 | #endif | |
1760 | } | |
1761 | ||
6b03cd10 | 1762 | /** |
78a88f79 MS |
1763 | * efi_exit_boot_services() - stop all boot services |
1764 | * @image_handle: handle of the loaded image | |
1765 | * @map_key: key of the memory map | |
332468f7 HS |
1766 | * |
1767 | * This function implements the ExitBootServices service. | |
78a88f79 | 1768 | * |
332468f7 HS |
1769 | * See the Unified Extensible Firmware Interface (UEFI) specification |
1770 | * for details. | |
1771 | * | |
78a88f79 MS |
1772 | * All timer events are disabled. For exit boot services events the |
1773 | * notification function is called. The boot services are disabled in the | |
1774 | * system table. | |
cc20ed03 | 1775 | * |
78a88f79 | 1776 | * Return: status code |
332468f7 | 1777 | */ |
2074f700 | 1778 | static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle, |
bee91169 AG |
1779 | unsigned long map_key) |
1780 | { | |
43bce442 | 1781 | struct efi_event *evt; |
152a263c | 1782 | |
bee91169 AG |
1783 | EFI_ENTRY("%p, %ld", image_handle, map_key); |
1784 | ||
1fcb7ea2 HS |
1785 | /* Check that the caller has read the current memory map */ |
1786 | if (map_key != efi_memory_map_key) | |
1787 | return EFI_INVALID_PARAMETER; | |
1788 | ||
cc20ed03 HS |
1789 | /* Make sure that notification functions are not called anymore */ |
1790 | efi_tpl = TPL_HIGH_LEVEL; | |
1791 | ||
1792 | /* Check if ExitBootServices has already been called */ | |
1793 | if (!systab.boottime) | |
1794 | return EFI_EXIT(EFI_SUCCESS); | |
1795 | ||
b095f3c8 HS |
1796 | /* Add related events to the event group */ |
1797 | list_for_each_entry(evt, &efi_events, link) { | |
1798 | if (evt->type == EVT_SIGNAL_EXIT_BOOT_SERVICES) | |
1799 | evt->group = &efi_guid_event_group_exit_boot_services; | |
1800 | } | |
152a263c | 1801 | /* Notify that ExitBootServices is invoked. */ |
43bce442 | 1802 | list_for_each_entry(evt, &efi_events, link) { |
b095f3c8 HS |
1803 | if (evt->group && |
1804 | !guidcmp(evt->group, | |
1805 | &efi_guid_event_group_exit_boot_services)) { | |
1806 | efi_signal_event(evt, false); | |
1807 | break; | |
1808 | } | |
152a263c | 1809 | } |
152a263c | 1810 | |
b72aaa87 | 1811 | /* TODO: Should persist EFI variables here */ |
ad644e7c | 1812 | |
b7b8410a AG |
1813 | board_quiesce_devices(); |
1814 | ||
f31239ac AG |
1815 | /* Fix up caches for EFI payloads if necessary */ |
1816 | efi_exit_caches(); | |
1817 | ||
bee91169 AG |
1818 | /* This stops all lingering devices */ |
1819 | bootm_disable_interrupts(); | |
1820 | ||
b72aaa87 | 1821 | /* Disable boot time services */ |
cc20ed03 HS |
1822 | systab.con_in_handle = NULL; |
1823 | systab.con_in = NULL; | |
1824 | systab.con_out_handle = NULL; | |
1825 | systab.con_out = NULL; | |
1826 | systab.stderr_handle = NULL; | |
1827 | systab.std_err = NULL; | |
1828 | systab.boottime = NULL; | |
1829 | ||
1830 | /* Recalculate CRC32 */ | |
640adadf | 1831 | efi_update_table_header_crc32(&systab.hdr); |
cc20ed03 | 1832 | |
bee91169 | 1833 | /* Give the payload some time to boot */ |
b3d60900 | 1834 | efi_set_watchdog(0); |
bee91169 AG |
1835 | WATCHDOG_RESET(); |
1836 | ||
1837 | return EFI_EXIT(EFI_SUCCESS); | |
1838 | } | |
1839 | ||
6b03cd10 | 1840 | /** |
78a88f79 MS |
1841 | * efi_get_next_monotonic_count() - get next value of the counter |
1842 | * @count: returned value of the counter | |
332468f7 HS |
1843 | * |
1844 | * This function implements the NextMonotonicCount service. | |
332468f7 | 1845 | * |
78a88f79 MS |
1846 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1847 | * details. | |
1848 | * | |
1849 | * Return: status code | |
332468f7 | 1850 | */ |
bee91169 AG |
1851 | static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count) |
1852 | { | |
ab9efa97 HS |
1853 | static uint64_t mono; |
1854 | ||
bee91169 AG |
1855 | EFI_ENTRY("%p", count); |
1856 | *count = mono++; | |
1857 | return EFI_EXIT(EFI_SUCCESS); | |
1858 | } | |
1859 | ||
6b03cd10 | 1860 | /** |
78a88f79 MS |
1861 | * efi_stall() - sleep |
1862 | * @microseconds: period to sleep in microseconds | |
332468f7 | 1863 | * |
78a88f79 | 1864 | * This function implements the Stall service. |
332468f7 | 1865 | * |
78a88f79 MS |
1866 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1867 | * details. | |
1868 | * | |
1869 | * Return: status code | |
332468f7 | 1870 | */ |
bee91169 AG |
1871 | static efi_status_t EFIAPI efi_stall(unsigned long microseconds) |
1872 | { | |
1873 | EFI_ENTRY("%ld", microseconds); | |
1874 | udelay(microseconds); | |
1875 | return EFI_EXIT(EFI_SUCCESS); | |
1876 | } | |
1877 | ||
6b03cd10 | 1878 | /** |
78a88f79 MS |
1879 | * efi_set_watchdog_timer() - reset the watchdog timer |
1880 | * @timeout: seconds before reset by watchdog | |
1881 | * @watchdog_code: code to be logged when resetting | |
1882 | * @data_size: size of buffer in bytes | |
1883 | * @watchdog_data: buffer with data describing the reset reason | |
332468f7 | 1884 | * |
b3d60900 | 1885 | * This function implements the SetWatchdogTimer service. |
332468f7 | 1886 | * |
78a88f79 MS |
1887 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1888 | * details. | |
1889 | * | |
1890 | * Return: status code | |
332468f7 | 1891 | */ |
bee91169 AG |
1892 | static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout, |
1893 | uint64_t watchdog_code, | |
1894 | unsigned long data_size, | |
1895 | uint16_t *watchdog_data) | |
1896 | { | |
dee37fc9 | 1897 | EFI_ENTRY("%ld, 0x%llx, %ld, %p", timeout, watchdog_code, |
bee91169 | 1898 | data_size, watchdog_data); |
b3d60900 | 1899 | return EFI_EXIT(efi_set_watchdog(timeout)); |
bee91169 AG |
1900 | } |
1901 | ||
6b03cd10 | 1902 | /** |
78a88f79 MS |
1903 | * efi_close_protocol() - close a protocol |
1904 | * @handle: handle on which the protocol shall be closed | |
1905 | * @protocol: GUID of the protocol to close | |
1906 | * @agent_handle: handle of the driver | |
1907 | * @controller_handle: handle of the controller | |
332468f7 HS |
1908 | * |
1909 | * This function implements the CloseProtocol service. | |
332468f7 | 1910 | * |
78a88f79 MS |
1911 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1912 | * details. | |
1913 | * | |
1914 | * Return: status code | |
332468f7 | 1915 | */ |
2074f700 | 1916 | static efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle, |
5a9682d0 | 1917 | const efi_guid_t *protocol, |
2074f700 HS |
1918 | efi_handle_t agent_handle, |
1919 | efi_handle_t controller_handle) | |
bee91169 | 1920 | { |
3b8a489c HS |
1921 | struct efi_handler *handler; |
1922 | struct efi_open_protocol_info_item *item; | |
1923 | struct efi_open_protocol_info_item *pos; | |
1924 | efi_status_t r; | |
1925 | ||
778e6af8 | 1926 | EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, agent_handle, |
bee91169 | 1927 | controller_handle); |
3b8a489c HS |
1928 | |
1929 | if (!agent_handle) { | |
1930 | r = EFI_INVALID_PARAMETER; | |
1931 | goto out; | |
1932 | } | |
1933 | r = efi_search_protocol(handle, protocol, &handler); | |
1934 | if (r != EFI_SUCCESS) | |
1935 | goto out; | |
1936 | ||
1937 | r = EFI_NOT_FOUND; | |
1938 | list_for_each_entry_safe(item, pos, &handler->open_infos, link) { | |
1939 | if (item->info.agent_handle == agent_handle && | |
1940 | item->info.controller_handle == controller_handle) { | |
1941 | efi_delete_open_info(item); | |
1942 | r = EFI_SUCCESS; | |
1943 | break; | |
1944 | } | |
1945 | } | |
1946 | out: | |
1947 | return EFI_EXIT(r); | |
bee91169 AG |
1948 | } |
1949 | ||
6b03cd10 | 1950 | /** |
78a88f79 MS |
1951 | * efi_open_protocol_information() - provide information about then open status |
1952 | * of a protocol on a handle | |
1953 | * @handle: handle for which the information shall be retrieved | |
1954 | * @protocol: GUID of the protocol | |
1955 | * @entry_buffer: buffer to receive the open protocol information | |
1956 | * @entry_count: number of entries available in the buffer | |
332468f7 HS |
1957 | * |
1958 | * This function implements the OpenProtocolInformation service. | |
332468f7 | 1959 | * |
78a88f79 MS |
1960 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
1961 | * details. | |
1962 | * | |
1963 | * Return: status code | |
332468f7 | 1964 | */ |
ab9efa97 HS |
1965 | static efi_status_t EFIAPI efi_open_protocol_information( |
1966 | efi_handle_t handle, const efi_guid_t *protocol, | |
bee91169 | 1967 | struct efi_open_protocol_info_entry **entry_buffer, |
f5a2a938 | 1968 | efi_uintn_t *entry_count) |
bee91169 | 1969 | { |
e3fbbc36 HS |
1970 | unsigned long buffer_size; |
1971 | unsigned long count; | |
1972 | struct efi_handler *handler; | |
1973 | struct efi_open_protocol_info_item *item; | |
1974 | efi_status_t r; | |
1975 | ||
778e6af8 | 1976 | EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, entry_buffer, |
bee91169 | 1977 | entry_count); |
e3fbbc36 HS |
1978 | |
1979 | /* Check parameters */ | |
1980 | if (!entry_buffer) { | |
1981 | r = EFI_INVALID_PARAMETER; | |
1982 | goto out; | |
1983 | } | |
1984 | r = efi_search_protocol(handle, protocol, &handler); | |
1985 | if (r != EFI_SUCCESS) | |
1986 | goto out; | |
1987 | ||
1988 | /* Count entries */ | |
1989 | count = 0; | |
1990 | list_for_each_entry(item, &handler->open_infos, link) { | |
1991 | if (item->info.open_count) | |
1992 | ++count; | |
1993 | } | |
1994 | *entry_count = count; | |
1995 | *entry_buffer = NULL; | |
1996 | if (!count) { | |
1997 | r = EFI_SUCCESS; | |
1998 | goto out; | |
1999 | } | |
2000 | ||
2001 | /* Copy entries */ | |
2002 | buffer_size = count * sizeof(struct efi_open_protocol_info_entry); | |
eee6530e | 2003 | r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size, |
e3fbbc36 HS |
2004 | (void **)entry_buffer); |
2005 | if (r != EFI_SUCCESS) | |
2006 | goto out; | |
2007 | list_for_each_entry_reverse(item, &handler->open_infos, link) { | |
2008 | if (item->info.open_count) | |
2009 | (*entry_buffer)[--count] = item->info; | |
2010 | } | |
2011 | out: | |
2012 | return EFI_EXIT(r); | |
bee91169 AG |
2013 | } |
2014 | ||
6b03cd10 | 2015 | /** |
78a88f79 MS |
2016 | * efi_protocols_per_handle() - get protocols installed on a handle |
2017 | * @handle: handle for which the information is retrieved | |
2018 | * @protocol_buffer: buffer with protocol GUIDs | |
2019 | * @protocol_buffer_count: number of entries in the buffer | |
332468f7 HS |
2020 | * |
2021 | * This function implements the ProtocolsPerHandleService. | |
332468f7 | 2022 | * |
78a88f79 MS |
2023 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2024 | * details. | |
2025 | * | |
2026 | * Return: status code | |
332468f7 | 2027 | */ |
2074f700 HS |
2028 | static efi_status_t EFIAPI efi_protocols_per_handle( |
2029 | efi_handle_t handle, efi_guid_t ***protocol_buffer, | |
f5a2a938 | 2030 | efi_uintn_t *protocol_buffer_count) |
bee91169 | 2031 | { |
c0ebfc86 HS |
2032 | unsigned long buffer_size; |
2033 | struct efi_object *efiobj; | |
69fb6b1a | 2034 | struct list_head *protocol_handle; |
c0ebfc86 HS |
2035 | efi_status_t r; |
2036 | ||
bee91169 AG |
2037 | EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, |
2038 | protocol_buffer_count); | |
c0ebfc86 HS |
2039 | |
2040 | if (!handle || !protocol_buffer || !protocol_buffer_count) | |
2041 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
2042 | ||
2043 | *protocol_buffer = NULL; | |
661c8327 | 2044 | *protocol_buffer_count = 0; |
c0ebfc86 | 2045 | |
69fb6b1a HS |
2046 | efiobj = efi_search_obj(handle); |
2047 | if (!efiobj) | |
2048 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
c0ebfc86 | 2049 | |
69fb6b1a HS |
2050 | /* Count protocols */ |
2051 | list_for_each(protocol_handle, &efiobj->protocols) { | |
2052 | ++*protocol_buffer_count; | |
2053 | } | |
2054 | ||
b72aaa87 | 2055 | /* Copy GUIDs */ |
69fb6b1a HS |
2056 | if (*protocol_buffer_count) { |
2057 | size_t j = 0; | |
2058 | ||
2059 | buffer_size = sizeof(efi_guid_t *) * *protocol_buffer_count; | |
eee6530e | 2060 | r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size, |
69fb6b1a HS |
2061 | (void **)protocol_buffer); |
2062 | if (r != EFI_SUCCESS) | |
2063 | return EFI_EXIT(r); | |
2064 | list_for_each(protocol_handle, &efiobj->protocols) { | |
2065 | struct efi_handler *protocol; | |
2066 | ||
2067 | protocol = list_entry(protocol_handle, | |
2068 | struct efi_handler, link); | |
2069 | (*protocol_buffer)[j] = (void *)protocol->guid; | |
2070 | ++j; | |
c0ebfc86 | 2071 | } |
c0ebfc86 HS |
2072 | } |
2073 | ||
2074 | return EFI_EXIT(EFI_SUCCESS); | |
bee91169 AG |
2075 | } |
2076 | ||
6b03cd10 | 2077 | /** |
78a88f79 MS |
2078 | * efi_locate_handle_buffer() - locate handles implementing a protocol |
2079 | * @search_type: selection criterion | |
2080 | * @protocol: GUID of the protocol | |
2081 | * @search_key: registration key | |
2082 | * @no_handles: number of returned handles | |
2083 | * @buffer: buffer with the returned handles | |
332468f7 HS |
2084 | * |
2085 | * This function implements the LocateHandleBuffer service. | |
332468f7 | 2086 | * |
78a88f79 MS |
2087 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2088 | * details. | |
2089 | * | |
2090 | * Return: status code | |
332468f7 | 2091 | */ |
bee91169 AG |
2092 | static efi_status_t EFIAPI efi_locate_handle_buffer( |
2093 | enum efi_locate_search_type search_type, | |
5a9682d0 | 2094 | const efi_guid_t *protocol, void *search_key, |
f5a2a938 | 2095 | efi_uintn_t *no_handles, efi_handle_t **buffer) |
bee91169 | 2096 | { |
c2e703f9 | 2097 | efi_status_t r; |
f5a2a938 | 2098 | efi_uintn_t buffer_size = 0; |
c2e703f9 | 2099 | |
778e6af8 | 2100 | EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key, |
bee91169 | 2101 | no_handles, buffer); |
c2e703f9 HS |
2102 | |
2103 | if (!no_handles || !buffer) { | |
2104 | r = EFI_INVALID_PARAMETER; | |
2105 | goto out; | |
2106 | } | |
2107 | *no_handles = 0; | |
2108 | *buffer = NULL; | |
2109 | r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, | |
2110 | *buffer); | |
2111 | if (r != EFI_BUFFER_TOO_SMALL) | |
2112 | goto out; | |
eee6530e | 2113 | r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size, |
c2e703f9 HS |
2114 | (void **)buffer); |
2115 | if (r != EFI_SUCCESS) | |
2116 | goto out; | |
2117 | r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, | |
2118 | *buffer); | |
2119 | if (r == EFI_SUCCESS) | |
2074f700 | 2120 | *no_handles = buffer_size / sizeof(efi_handle_t); |
c2e703f9 HS |
2121 | out: |
2122 | return EFI_EXIT(r); | |
bee91169 AG |
2123 | } |
2124 | ||
6b03cd10 | 2125 | /** |
78a88f79 MS |
2126 | * efi_locate_protocol() - find an interface implementing a protocol |
2127 | * @protocol: GUID of the protocol | |
2128 | * @registration: registration key passed to the notification function | |
2129 | * @protocol_interface: interface implementing the protocol | |
332468f7 HS |
2130 | * |
2131 | * This function implements the LocateProtocol service. | |
332468f7 | 2132 | * |
78a88f79 MS |
2133 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2134 | * details. | |
2135 | * | |
2136 | * Return: status code | |
332468f7 | 2137 | */ |
5a9682d0 | 2138 | static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol, |
bee91169 AG |
2139 | void *registration, |
2140 | void **protocol_interface) | |
2141 | { | |
88adae5e | 2142 | struct list_head *lhandle; |
9172cd91 | 2143 | efi_status_t ret; |
bee91169 | 2144 | |
778e6af8 | 2145 | EFI_ENTRY("%pUl, %p, %p", protocol, registration, protocol_interface); |
88adae5e HS |
2146 | |
2147 | if (!protocol || !protocol_interface) | |
2148 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
2149 | ||
2150 | list_for_each(lhandle, &efi_obj_list) { | |
2151 | struct efi_object *efiobj; | |
9172cd91 | 2152 | struct efi_handler *handler; |
88adae5e HS |
2153 | |
2154 | efiobj = list_entry(lhandle, struct efi_object, link); | |
9172cd91 | 2155 | |
fae0118e | 2156 | ret = efi_search_protocol(efiobj, protocol, &handler); |
9172cd91 HS |
2157 | if (ret == EFI_SUCCESS) { |
2158 | *protocol_interface = handler->protocol_interface; | |
2159 | return EFI_EXIT(EFI_SUCCESS); | |
bee91169 AG |
2160 | } |
2161 | } | |
88adae5e | 2162 | *protocol_interface = NULL; |
bee91169 AG |
2163 | |
2164 | return EFI_EXIT(EFI_NOT_FOUND); | |
2165 | } | |
2166 | ||
6b03cd10 | 2167 | /** |
78a88f79 MS |
2168 | * efi_locate_device_path() - Get the device path and handle of an device |
2169 | * implementing a protocol | |
2170 | * @protocol: GUID of the protocol | |
2171 | * @device_path: device path | |
2172 | * @device: handle of the device | |
ae2c85c1 HS |
2173 | * |
2174 | * This function implements the LocateDevicePath service. | |
ae2c85c1 | 2175 | * |
78a88f79 MS |
2176 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2177 | * details. | |
2178 | * | |
2179 | * Return: status code | |
ae2c85c1 HS |
2180 | */ |
2181 | static efi_status_t EFIAPI efi_locate_device_path( | |
2182 | const efi_guid_t *protocol, | |
2183 | struct efi_device_path **device_path, | |
2184 | efi_handle_t *device) | |
2185 | { | |
2186 | struct efi_device_path *dp; | |
2187 | size_t i; | |
2188 | struct efi_handler *handler; | |
2189 | efi_handle_t *handles; | |
2190 | size_t len, len_dp; | |
2191 | size_t len_best = 0; | |
2192 | efi_uintn_t no_handles; | |
2193 | u8 *remainder; | |
2194 | efi_status_t ret; | |
2195 | ||
2196 | EFI_ENTRY("%pUl, %p, %p", protocol, device_path, device); | |
2197 | ||
2198 | if (!protocol || !device_path || !*device_path || !device) { | |
2199 | ret = EFI_INVALID_PARAMETER; | |
2200 | goto out; | |
2201 | } | |
2202 | ||
2203 | /* Find end of device path */ | |
f6dd3f35 | 2204 | len = efi_dp_instance_size(*device_path); |
ae2c85c1 HS |
2205 | |
2206 | /* Get all handles implementing the protocol */ | |
2207 | ret = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL, protocol, NULL, | |
2208 | &no_handles, &handles)); | |
2209 | if (ret != EFI_SUCCESS) | |
2210 | goto out; | |
2211 | ||
2212 | for (i = 0; i < no_handles; ++i) { | |
2213 | /* Find the device path protocol */ | |
2214 | ret = efi_search_protocol(handles[i], &efi_guid_device_path, | |
2215 | &handler); | |
2216 | if (ret != EFI_SUCCESS) | |
2217 | continue; | |
2218 | dp = (struct efi_device_path *)handler->protocol_interface; | |
f6dd3f35 | 2219 | len_dp = efi_dp_instance_size(dp); |
ae2c85c1 HS |
2220 | /* |
2221 | * This handle can only be a better fit | |
2222 | * if its device path length is longer than the best fit and | |
2223 | * if its device path length is shorter of equal the searched | |
2224 | * device path. | |
2225 | */ | |
2226 | if (len_dp <= len_best || len_dp > len) | |
2227 | continue; | |
2228 | /* Check if dp is a subpath of device_path */ | |
2229 | if (memcmp(*device_path, dp, len_dp)) | |
2230 | continue; | |
2231 | *device = handles[i]; | |
2232 | len_best = len_dp; | |
2233 | } | |
2234 | if (len_best) { | |
2235 | remainder = (u8 *)*device_path + len_best; | |
2236 | *device_path = (struct efi_device_path *)remainder; | |
2237 | ret = EFI_SUCCESS; | |
2238 | } else { | |
2239 | ret = EFI_NOT_FOUND; | |
2240 | } | |
2241 | out: | |
2242 | return EFI_EXIT(ret); | |
2243 | } | |
2244 | ||
6b03cd10 | 2245 | /** |
78a88f79 MS |
2246 | * efi_install_multiple_protocol_interfaces() - Install multiple protocol |
2247 | * interfaces | |
2248 | * @handle: handle on which the protocol interfaces shall be installed | |
2249 | * @...: NULL terminated argument list with pairs of protocol GUIDS and | |
2250 | * interfaces | |
332468f7 HS |
2251 | * |
2252 | * This function implements the MultipleProtocolInterfaces service. | |
332468f7 | 2253 | * |
78a88f79 MS |
2254 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2255 | * details. | |
2256 | * | |
2257 | * Return: status code | |
332468f7 | 2258 | */ |
7657ae12 | 2259 | efi_status_t EFIAPI efi_install_multiple_protocol_interfaces |
faea1041 | 2260 | (efi_handle_t *handle, ...) |
bee91169 AG |
2261 | { |
2262 | EFI_ENTRY("%p", handle); | |
58b83586 | 2263 | |
beb077a2 | 2264 | efi_va_list argptr; |
5a9682d0 | 2265 | const efi_guid_t *protocol; |
58b83586 HS |
2266 | void *protocol_interface; |
2267 | efi_status_t r = EFI_SUCCESS; | |
2268 | int i = 0; | |
2269 | ||
2270 | if (!handle) | |
2271 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
2272 | ||
beb077a2 | 2273 | efi_va_start(argptr, handle); |
58b83586 | 2274 | for (;;) { |
beb077a2 | 2275 | protocol = efi_va_arg(argptr, efi_guid_t*); |
58b83586 HS |
2276 | if (!protocol) |
2277 | break; | |
beb077a2 | 2278 | protocol_interface = efi_va_arg(argptr, void*); |
1760ef57 HS |
2279 | r = EFI_CALL(efi_install_protocol_interface( |
2280 | handle, protocol, | |
2281 | EFI_NATIVE_INTERFACE, | |
2282 | protocol_interface)); | |
58b83586 HS |
2283 | if (r != EFI_SUCCESS) |
2284 | break; | |
2285 | i++; | |
2286 | } | |
beb077a2 | 2287 | efi_va_end(argptr); |
58b83586 HS |
2288 | if (r == EFI_SUCCESS) |
2289 | return EFI_EXIT(r); | |
2290 | ||
62471e46 | 2291 | /* If an error occurred undo all changes. */ |
beb077a2 | 2292 | efi_va_start(argptr, handle); |
58b83586 | 2293 | for (; i; --i) { |
beb077a2 AG |
2294 | protocol = efi_va_arg(argptr, efi_guid_t*); |
2295 | protocol_interface = efi_va_arg(argptr, void*); | |
faea1041 | 2296 | EFI_CALL(efi_uninstall_protocol_interface(*handle, protocol, |
cd534083 | 2297 | protocol_interface)); |
58b83586 | 2298 | } |
beb077a2 | 2299 | efi_va_end(argptr); |
58b83586 HS |
2300 | |
2301 | return EFI_EXIT(r); | |
bee91169 AG |
2302 | } |
2303 | ||
6b03cd10 | 2304 | /** |
78a88f79 MS |
2305 | * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol |
2306 | * interfaces | |
2307 | * @handle: handle from which the protocol interfaces shall be removed | |
2308 | * @...: NULL terminated argument list with pairs of protocol GUIDS and | |
2309 | * interfaces | |
332468f7 HS |
2310 | * |
2311 | * This function implements the UninstallMultipleProtocolInterfaces service. | |
332468f7 | 2312 | * |
78a88f79 MS |
2313 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2314 | * details. | |
2315 | * | |
2316 | * Return: status code | |
332468f7 | 2317 | */ |
bee91169 | 2318 | static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( |
faea1041 | 2319 | efi_handle_t handle, ...) |
bee91169 AG |
2320 | { |
2321 | EFI_ENTRY("%p", handle); | |
843ce54c | 2322 | |
beb077a2 | 2323 | efi_va_list argptr; |
843ce54c HS |
2324 | const efi_guid_t *protocol; |
2325 | void *protocol_interface; | |
2326 | efi_status_t r = EFI_SUCCESS; | |
2327 | size_t i = 0; | |
2328 | ||
2329 | if (!handle) | |
2330 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
2331 | ||
beb077a2 | 2332 | efi_va_start(argptr, handle); |
843ce54c | 2333 | for (;;) { |
beb077a2 | 2334 | protocol = efi_va_arg(argptr, efi_guid_t*); |
843ce54c HS |
2335 | if (!protocol) |
2336 | break; | |
beb077a2 | 2337 | protocol_interface = efi_va_arg(argptr, void*); |
9b47f13b HS |
2338 | r = efi_uninstall_protocol(handle, protocol, |
2339 | protocol_interface); | |
843ce54c HS |
2340 | if (r != EFI_SUCCESS) |
2341 | break; | |
2342 | i++; | |
2343 | } | |
beb077a2 | 2344 | efi_va_end(argptr); |
9b47f13b HS |
2345 | if (r == EFI_SUCCESS) { |
2346 | /* If the last protocol has been removed, delete the handle. */ | |
2347 | if (list_empty(&handle->protocols)) { | |
2348 | list_del(&handle->link); | |
2349 | free(handle); | |
2350 | } | |
843ce54c | 2351 | return EFI_EXIT(r); |
9b47f13b | 2352 | } |
843ce54c HS |
2353 | |
2354 | /* If an error occurred undo all changes. */ | |
beb077a2 | 2355 | efi_va_start(argptr, handle); |
843ce54c | 2356 | for (; i; --i) { |
beb077a2 AG |
2357 | protocol = efi_va_arg(argptr, efi_guid_t*); |
2358 | protocol_interface = efi_va_arg(argptr, void*); | |
843ce54c HS |
2359 | EFI_CALL(efi_install_protocol_interface(&handle, protocol, |
2360 | EFI_NATIVE_INTERFACE, | |
2361 | protocol_interface)); | |
2362 | } | |
beb077a2 | 2363 | efi_va_end(argptr); |
843ce54c | 2364 | |
e2373021 HS |
2365 | /* In case of an error always return EFI_INVALID_PARAMETER */ |
2366 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
bee91169 AG |
2367 | } |
2368 | ||
6b03cd10 | 2369 | /** |
78a88f79 MS |
2370 | * efi_calculate_crc32() - calculate cyclic redundancy code |
2371 | * @data: buffer with data | |
2372 | * @data_size: size of buffer in bytes | |
2373 | * @crc32_p: cyclic redundancy code | |
332468f7 HS |
2374 | * |
2375 | * This function implements the CalculateCrc32 service. | |
332468f7 | 2376 | * |
78a88f79 MS |
2377 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2378 | * details. | |
2379 | * | |
2380 | * Return: status code | |
332468f7 | 2381 | */ |
8aa8360e HS |
2382 | static efi_status_t EFIAPI efi_calculate_crc32(const void *data, |
2383 | efi_uintn_t data_size, | |
2384 | u32 *crc32_p) | |
bee91169 | 2385 | { |
8aa8360e | 2386 | EFI_ENTRY("%p, %zu", data, data_size); |
bee91169 AG |
2387 | *crc32_p = crc32(0, data, data_size); |
2388 | return EFI_EXIT(EFI_SUCCESS); | |
2389 | } | |
2390 | ||
6b03cd10 | 2391 | /** |
78a88f79 MS |
2392 | * efi_copy_mem() - copy memory |
2393 | * @destination: destination of the copy operation | |
2394 | * @source: source of the copy operation | |
2395 | * @length: number of bytes to copy | |
332468f7 HS |
2396 | * |
2397 | * This function implements the CopyMem service. | |
332468f7 | 2398 | * |
78a88f79 MS |
2399 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2400 | * details. | |
332468f7 | 2401 | */ |
fc05a959 HS |
2402 | static void EFIAPI efi_copy_mem(void *destination, const void *source, |
2403 | size_t length) | |
bee91169 | 2404 | { |
fc05a959 | 2405 | EFI_ENTRY("%p, %p, %ld", destination, source, (unsigned long)length); |
0bc81a71 | 2406 | memmove(destination, source, length); |
f7c78176 | 2407 | EFI_EXIT(EFI_SUCCESS); |
bee91169 AG |
2408 | } |
2409 | ||
6b03cd10 | 2410 | /** |
78a88f79 MS |
2411 | * efi_set_mem() - Fill memory with a byte value. |
2412 | * @buffer: buffer to fill | |
2413 | * @size: size of buffer in bytes | |
2414 | * @value: byte to copy to the buffer | |
332468f7 HS |
2415 | * |
2416 | * This function implements the SetMem service. | |
332468f7 | 2417 | * |
78a88f79 MS |
2418 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2419 | * details. | |
332468f7 | 2420 | */ |
fc05a959 | 2421 | static void EFIAPI efi_set_mem(void *buffer, size_t size, uint8_t value) |
bee91169 | 2422 | { |
fc05a959 | 2423 | EFI_ENTRY("%p, %ld, 0x%x", buffer, (unsigned long)size, value); |
bee91169 | 2424 | memset(buffer, value, size); |
f7c78176 | 2425 | EFI_EXIT(EFI_SUCCESS); |
bee91169 AG |
2426 | } |
2427 | ||
6b03cd10 | 2428 | /** |
78a88f79 MS |
2429 | * efi_protocol_open() - open protocol interface on a handle |
2430 | * @handler: handler of a protocol | |
2431 | * @protocol_interface: interface implementing the protocol | |
2432 | * @agent_handle: handle of the driver | |
2433 | * @controller_handle: handle of the controller | |
2434 | * @attributes: attributes indicating how to open the protocol | |
191a41cc | 2435 | * |
78a88f79 | 2436 | * Return: status code |
191a41cc HS |
2437 | */ |
2438 | static efi_status_t efi_protocol_open( | |
2439 | struct efi_handler *handler, | |
2440 | void **protocol_interface, void *agent_handle, | |
2441 | void *controller_handle, uint32_t attributes) | |
2442 | { | |
2443 | struct efi_open_protocol_info_item *item; | |
2444 | struct efi_open_protocol_info_entry *match = NULL; | |
2445 | bool opened_by_driver = false; | |
2446 | bool opened_exclusive = false; | |
2447 | ||
2448 | /* If there is no agent, only return the interface */ | |
2449 | if (!agent_handle) | |
2450 | goto out; | |
2451 | ||
2452 | /* For TEST_PROTOCOL ignore interface attribute */ | |
2453 | if (attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL) | |
2454 | *protocol_interface = NULL; | |
2455 | ||
2456 | /* | |
2457 | * Check if the protocol is already opened by a driver with the same | |
2458 | * attributes or opened exclusively | |
2459 | */ | |
2460 | list_for_each_entry(item, &handler->open_infos, link) { | |
2461 | if (item->info.agent_handle == agent_handle) { | |
2462 | if ((attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) && | |
2463 | (item->info.attributes == attributes)) | |
2464 | return EFI_ALREADY_STARTED; | |
2465 | } | |
2466 | if (item->info.attributes & EFI_OPEN_PROTOCOL_EXCLUSIVE) | |
2467 | opened_exclusive = true; | |
2468 | } | |
2469 | ||
2470 | /* Only one controller can open the protocol exclusively */ | |
2471 | if (opened_exclusive && attributes & | |
2472 | (EFI_OPEN_PROTOCOL_EXCLUSIVE | EFI_OPEN_PROTOCOL_BY_DRIVER)) | |
2473 | return EFI_ACCESS_DENIED; | |
2474 | ||
2475 | /* Prepare exclusive opening */ | |
2476 | if (attributes & EFI_OPEN_PROTOCOL_EXCLUSIVE) { | |
2477 | /* Try to disconnect controllers */ | |
2478 | list_for_each_entry(item, &handler->open_infos, link) { | |
2479 | if (item->info.attributes == | |
2480 | EFI_OPEN_PROTOCOL_BY_DRIVER) | |
2481 | EFI_CALL(efi_disconnect_controller( | |
2482 | item->info.controller_handle, | |
2483 | item->info.agent_handle, | |
2484 | NULL)); | |
2485 | } | |
2486 | opened_by_driver = false; | |
2487 | /* Check if all controllers are disconnected */ | |
2488 | list_for_each_entry(item, &handler->open_infos, link) { | |
2489 | if (item->info.attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) | |
2490 | opened_by_driver = true; | |
2491 | } | |
4f37fa47 | 2492 | /* Only one controller can be connected */ |
191a41cc HS |
2493 | if (opened_by_driver) |
2494 | return EFI_ACCESS_DENIED; | |
2495 | } | |
2496 | ||
2497 | /* Find existing entry */ | |
2498 | list_for_each_entry(item, &handler->open_infos, link) { | |
2499 | if (item->info.agent_handle == agent_handle && | |
2500 | item->info.controller_handle == controller_handle) | |
2501 | match = &item->info; | |
2502 | } | |
2503 | /* None found, create one */ | |
2504 | if (!match) { | |
2505 | match = efi_create_open_info(handler); | |
2506 | if (!match) | |
2507 | return EFI_OUT_OF_RESOURCES; | |
2508 | } | |
2509 | ||
2510 | match->agent_handle = agent_handle; | |
2511 | match->controller_handle = controller_handle; | |
2512 | match->attributes = attributes; | |
2513 | match->open_count++; | |
2514 | ||
2515 | out: | |
2516 | /* For TEST_PROTOCOL ignore interface attribute. */ | |
2517 | if (attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL) | |
2518 | *protocol_interface = handler->protocol_interface; | |
2519 | ||
2520 | return EFI_SUCCESS; | |
2521 | } | |
2522 | ||
6b03cd10 | 2523 | /** |
78a88f79 MS |
2524 | * efi_open_protocol() - open protocol interface on a handle |
2525 | * @handle: handle on which the protocol shall be opened | |
2526 | * @protocol: GUID of the protocol | |
2527 | * @protocol_interface: interface implementing the protocol | |
2528 | * @agent_handle: handle of the driver | |
2529 | * @controller_handle: handle of the controller | |
2530 | * @attributes: attributes indicating how to open the protocol | |
332468f7 HS |
2531 | * |
2532 | * This function implements the OpenProtocol interface. | |
332468f7 | 2533 | * |
78a88f79 MS |
2534 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2535 | * details. | |
2536 | * | |
2537 | * Return: status code | |
332468f7 | 2538 | */ |
faea1041 HS |
2539 | static efi_status_t EFIAPI efi_open_protocol |
2540 | (efi_handle_t handle, const efi_guid_t *protocol, | |
2541 | void **protocol_interface, efi_handle_t agent_handle, | |
2542 | efi_handle_t controller_handle, uint32_t attributes) | |
bee91169 | 2543 | { |
80286e8f | 2544 | struct efi_handler *handler; |
69baec67 | 2545 | efi_status_t r = EFI_INVALID_PARAMETER; |
bee91169 | 2546 | |
778e6af8 | 2547 | EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle, protocol, |
bee91169 AG |
2548 | protocol_interface, agent_handle, controller_handle, |
2549 | attributes); | |
b5349f74 | 2550 | |
69baec67 HS |
2551 | if (!handle || !protocol || |
2552 | (!protocol_interface && attributes != | |
2553 | EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) { | |
2554 | goto out; | |
2555 | } | |
2556 | ||
2557 | switch (attributes) { | |
2558 | case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: | |
2559 | case EFI_OPEN_PROTOCOL_GET_PROTOCOL: | |
2560 | case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: | |
2561 | break; | |
2562 | case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: | |
2563 | if (controller_handle == handle) | |
2564 | goto out; | |
191a41cc | 2565 | /* fall-through */ |
69baec67 HS |
2566 | case EFI_OPEN_PROTOCOL_BY_DRIVER: |
2567 | case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE: | |
191a41cc HS |
2568 | /* Check that the controller handle is valid */ |
2569 | if (!efi_search_obj(controller_handle)) | |
69baec67 | 2570 | goto out; |
191a41cc | 2571 | /* fall-through */ |
69baec67 | 2572 | case EFI_OPEN_PROTOCOL_EXCLUSIVE: |
191a41cc HS |
2573 | /* Check that the agent handle is valid */ |
2574 | if (!efi_search_obj(agent_handle)) | |
69baec67 HS |
2575 | goto out; |
2576 | break; | |
2577 | default: | |
b5349f74 HS |
2578 | goto out; |
2579 | } | |
2580 | ||
80286e8f HS |
2581 | r = efi_search_protocol(handle, protocol, &handler); |
2582 | if (r != EFI_SUCCESS) | |
2583 | goto out; | |
bee91169 | 2584 | |
191a41cc HS |
2585 | r = efi_protocol_open(handler, protocol_interface, agent_handle, |
2586 | controller_handle, attributes); | |
bee91169 AG |
2587 | out: |
2588 | return EFI_EXIT(r); | |
2589 | } | |
2590 | ||
a115d565 HS |
2591 | /** |
2592 | * efi_start_image() - call the entry point of an image | |
2593 | * @image_handle: handle of the image | |
2594 | * @exit_data_size: size of the buffer | |
2595 | * @exit_data: buffer to receive the exit data of the called image | |
2596 | * | |
2597 | * This function implements the StartImage service. | |
2598 | * | |
2599 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
2600 | * details. | |
2601 | * | |
2602 | * Return: status code | |
2603 | */ | |
2604 | efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, | |
2605 | efi_uintn_t *exit_data_size, | |
2606 | u16 **exit_data) | |
2607 | { | |
2608 | struct efi_loaded_image_obj *image_obj = | |
2609 | (struct efi_loaded_image_obj *)image_handle; | |
2610 | efi_status_t ret; | |
bb31c3f7 HS |
2611 | void *info; |
2612 | efi_handle_t parent_image = current_image; | |
a115d565 HS |
2613 | |
2614 | EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data); | |
2615 | ||
bb31c3f7 HS |
2616 | /* Check parameters */ |
2617 | ret = EFI_CALL(efi_open_protocol(image_handle, &efi_guid_loaded_image, | |
2618 | &info, NULL, NULL, | |
2619 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
2620 | if (ret != EFI_SUCCESS) | |
2621 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
2622 | ||
a115d565 HS |
2623 | efi_is_direct_boot = false; |
2624 | ||
556d8dc9 HS |
2625 | image_obj->exit_data_size = exit_data_size; |
2626 | image_obj->exit_data = exit_data; | |
2627 | ||
a115d565 HS |
2628 | /* call the image! */ |
2629 | if (setjmp(&image_obj->exit_jmp)) { | |
2630 | /* | |
2631 | * We called the entry point of the child image with EFI_CALL | |
2632 | * in the lines below. The child image called the Exit() boot | |
2633 | * service efi_exit() which executed the long jump that brought | |
2634 | * us to the current line. This implies that the second half | |
2635 | * of the EFI_CALL macro has not been executed. | |
2636 | */ | |
2637 | #ifdef CONFIG_ARM | |
2638 | /* | |
2639 | * efi_exit() called efi_restore_gd(). We have to undo this | |
2640 | * otherwise __efi_entry_check() will put the wrong value into | |
2641 | * app_gd. | |
2642 | */ | |
2643 | gd = app_gd; | |
2644 | #endif | |
2645 | /* | |
2646 | * To get ready to call EFI_EXIT below we have to execute the | |
2647 | * missed out steps of EFI_CALL. | |
2648 | */ | |
2649 | assert(__efi_entry_check()); | |
2650 | debug("%sEFI: %lu returned by started image\n", | |
2651 | __efi_nesting_dec(), | |
2652 | (unsigned long)((uintptr_t)image_obj->exit_status & | |
2653 | ~EFI_ERROR_MASK)); | |
bb31c3f7 | 2654 | current_image = parent_image; |
a115d565 HS |
2655 | return EFI_EXIT(image_obj->exit_status); |
2656 | } | |
2657 | ||
bb31c3f7 | 2658 | current_image = image_handle; |
cd73aba6 | 2659 | image_obj->header.type = EFI_OBJECT_TYPE_STARTED_IMAGE; |
6b95b38c | 2660 | EFI_PRINT("Jumping into 0x%p\n", image_obj->entry); |
a115d565 HS |
2661 | ret = EFI_CALL(image_obj->entry(image_handle, &systab)); |
2662 | ||
2663 | /* | |
2664 | * Usually UEFI applications call Exit() instead of returning. | |
2665 | * But because the world doesn't consist of ponies and unicorns, | |
2666 | * we're happy to emulate that behavior on behalf of a payload | |
2667 | * that forgot. | |
2668 | */ | |
2669 | return EFI_CALL(systab.boottime->exit(image_handle, ret, 0, NULL)); | |
2670 | } | |
2671 | ||
46e99a9c HS |
2672 | /** |
2673 | * efi_unload_image() - unload an EFI image | |
2674 | * @image_handle: handle of the image to be unloaded | |
2675 | * | |
2676 | * This function implements the UnloadImage service. | |
2677 | * | |
2678 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
2679 | * details. | |
2680 | * | |
2681 | * Return: status code | |
2682 | */ | |
2683 | efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle) | |
2684 | { | |
2685 | struct efi_object *efiobj; | |
2686 | ||
2687 | EFI_ENTRY("%p", image_handle); | |
2688 | efiobj = efi_search_obj(image_handle); | |
2689 | if (efiobj) | |
2690 | list_del(&efiobj->link); | |
2691 | ||
2692 | return EFI_EXIT(EFI_SUCCESS); | |
2693 | } | |
2694 | ||
556d8dc9 HS |
2695 | /** |
2696 | * efi_update_exit_data() - fill exit data parameters of StartImage() | |
2697 | * | |
2698 | * @image_obj image handle | |
2699 | * @exit_data_size size of the exit data buffer | |
2700 | * @exit_data buffer with data returned by UEFI payload | |
2701 | * Return: status code | |
2702 | */ | |
2703 | static efi_status_t efi_update_exit_data(struct efi_loaded_image_obj *image_obj, | |
2704 | efi_uintn_t exit_data_size, | |
2705 | u16 *exit_data) | |
2706 | { | |
2707 | efi_status_t ret; | |
2708 | ||
2709 | /* | |
2710 | * If exit_data is not provided to StartImage(), exit_data_size must be | |
2711 | * ignored. | |
2712 | */ | |
2713 | if (!image_obj->exit_data) | |
2714 | return EFI_SUCCESS; | |
2715 | if (image_obj->exit_data_size) | |
2716 | *image_obj->exit_data_size = exit_data_size; | |
2717 | if (exit_data_size && exit_data) { | |
2718 | ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, | |
2719 | exit_data_size, | |
2720 | (void **)image_obj->exit_data); | |
2721 | if (ret != EFI_SUCCESS) | |
2722 | return ret; | |
2723 | memcpy(*image_obj->exit_data, exit_data, exit_data_size); | |
2724 | } else { | |
2725 | image_obj->exit_data = NULL; | |
2726 | } | |
2727 | return EFI_SUCCESS; | |
2728 | } | |
2729 | ||
a115d565 HS |
2730 | /** |
2731 | * efi_exit() - leave an EFI application or driver | |
2732 | * @image_handle: handle of the application or driver that is exiting | |
2733 | * @exit_status: status code | |
2734 | * @exit_data_size: size of the buffer in bytes | |
2735 | * @exit_data: buffer with data describing an error | |
2736 | * | |
2737 | * This function implements the Exit service. | |
2738 | * | |
2739 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
2740 | * details. | |
2741 | * | |
2742 | * Return: status code | |
2743 | */ | |
2744 | static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle, | |
2745 | efi_status_t exit_status, | |
2746 | efi_uintn_t exit_data_size, | |
2747 | u16 *exit_data) | |
2748 | { | |
2749 | /* | |
2750 | * TODO: We should call the unload procedure of the loaded | |
2751 | * image protocol. | |
2752 | */ | |
bb31c3f7 HS |
2753 | efi_status_t ret; |
2754 | void *info; | |
a115d565 HS |
2755 | struct efi_loaded_image_obj *image_obj = |
2756 | (struct efi_loaded_image_obj *)image_handle; | |
2757 | ||
2758 | EFI_ENTRY("%p, %ld, %zu, %p", image_handle, exit_status, | |
2759 | exit_data_size, exit_data); | |
2760 | ||
bb31c3f7 HS |
2761 | /* Check parameters */ |
2762 | if (image_handle != current_image) | |
2763 | goto out; | |
2764 | ret = EFI_CALL(efi_open_protocol(image_handle, &efi_guid_loaded_image, | |
2765 | &info, NULL, NULL, | |
2766 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
2767 | if (ret != EFI_SUCCESS) | |
2768 | goto out; | |
2769 | ||
556d8dc9 HS |
2770 | /* Exit data is only foreseen in case of failure. */ |
2771 | if (exit_status != EFI_SUCCESS) { | |
2772 | ret = efi_update_exit_data(image_obj, exit_data_size, | |
2773 | exit_data); | |
2774 | /* Exiting has priority. Don't return error to caller. */ | |
2775 | if (ret != EFI_SUCCESS) | |
2776 | EFI_PRINT("%s: out of memory\n", __func__); | |
2777 | } | |
2778 | ||
a115d565 HS |
2779 | /* Make sure entry/exit counts for EFI world cross-overs match */ |
2780 | EFI_EXIT(exit_status); | |
2781 | ||
2782 | /* | |
2783 | * But longjmp out with the U-Boot gd, not the application's, as | |
2784 | * the other end is a setjmp call inside EFI context. | |
2785 | */ | |
2786 | efi_restore_gd(); | |
2787 | ||
2788 | image_obj->exit_status = exit_status; | |
2789 | longjmp(&image_obj->exit_jmp, 1); | |
2790 | ||
2791 | panic("EFI application exited"); | |
bb31c3f7 HS |
2792 | out: |
2793 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
a115d565 HS |
2794 | } |
2795 | ||
6b03cd10 | 2796 | /** |
78a88f79 MS |
2797 | * efi_handle_protocol() - get interface of a protocol on a handle |
2798 | * @handle: handle on which the protocol shall be opened | |
2799 | * @protocol: GUID of the protocol | |
2800 | * @protocol_interface: interface implementing the protocol | |
332468f7 HS |
2801 | * |
2802 | * This function implements the HandleProtocol service. | |
332468f7 | 2803 | * |
78a88f79 MS |
2804 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
2805 | * details. | |
2806 | * | |
2807 | * Return: status code | |
332468f7 | 2808 | */ |
2074f700 | 2809 | static efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle, |
5a9682d0 | 2810 | const efi_guid_t *protocol, |
bee91169 AG |
2811 | void **protocol_interface) |
2812 | { | |
8e1d329f HS |
2813 | return efi_open_protocol(handle, protocol, protocol_interface, NULL, |
2814 | NULL, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL); | |
bee91169 AG |
2815 | } |
2816 | ||
6b03cd10 | 2817 | /** |
78a88f79 MS |
2818 | * efi_bind_controller() - bind a single driver to a controller |
2819 | * @controller_handle: controller handle | |
2820 | * @driver_image_handle: driver handle | |
2821 | * @remain_device_path: remaining path | |
6b03cd10 | 2822 | * |
78a88f79 | 2823 | * Return: status code |
6b03cd10 | 2824 | */ |
f0959dbe HS |
2825 | static efi_status_t efi_bind_controller( |
2826 | efi_handle_t controller_handle, | |
2827 | efi_handle_t driver_image_handle, | |
2828 | struct efi_device_path *remain_device_path) | |
2829 | { | |
2830 | struct efi_driver_binding_protocol *binding_protocol; | |
2831 | efi_status_t r; | |
2832 | ||
2833 | r = EFI_CALL(efi_open_protocol(driver_image_handle, | |
2834 | &efi_guid_driver_binding_protocol, | |
2835 | (void **)&binding_protocol, | |
2836 | driver_image_handle, NULL, | |
2837 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
2838 | if (r != EFI_SUCCESS) | |
2839 | return r; | |
2840 | r = EFI_CALL(binding_protocol->supported(binding_protocol, | |
2841 | controller_handle, | |
2842 | remain_device_path)); | |
2843 | if (r == EFI_SUCCESS) | |
2844 | r = EFI_CALL(binding_protocol->start(binding_protocol, | |
2845 | controller_handle, | |
2846 | remain_device_path)); | |
2847 | EFI_CALL(efi_close_protocol(driver_image_handle, | |
2848 | &efi_guid_driver_binding_protocol, | |
2849 | driver_image_handle, NULL)); | |
2850 | return r; | |
2851 | } | |
2852 | ||
6b03cd10 | 2853 | /** |
78a88f79 MS |
2854 | * efi_connect_single_controller() - connect a single driver to a controller |
2855 | * @controller_handle: controller | |
2856 | * @driver_image_handle: driver | |
b72aaa87 | 2857 | * @remain_device_path: remaining path |
6b03cd10 | 2858 | * |
78a88f79 | 2859 | * Return: status code |
6b03cd10 | 2860 | */ |
f0959dbe HS |
2861 | static efi_status_t efi_connect_single_controller( |
2862 | efi_handle_t controller_handle, | |
2863 | efi_handle_t *driver_image_handle, | |
2864 | struct efi_device_path *remain_device_path) | |
2865 | { | |
2866 | efi_handle_t *buffer; | |
2867 | size_t count; | |
2868 | size_t i; | |
2869 | efi_status_t r; | |
2870 | size_t connected = 0; | |
2871 | ||
2872 | /* Get buffer with all handles with driver binding protocol */ | |
2873 | r = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL, | |
2874 | &efi_guid_driver_binding_protocol, | |
2875 | NULL, &count, &buffer)); | |
2876 | if (r != EFI_SUCCESS) | |
2877 | return r; | |
2878 | ||
2879 | /* Context Override */ | |
2880 | if (driver_image_handle) { | |
2881 | for (; *driver_image_handle; ++driver_image_handle) { | |
2882 | for (i = 0; i < count; ++i) { | |
2883 | if (buffer[i] == *driver_image_handle) { | |
2884 | buffer[i] = NULL; | |
2885 | r = efi_bind_controller( | |
2886 | controller_handle, | |
2887 | *driver_image_handle, | |
2888 | remain_device_path); | |
2889 | /* | |
2890 | * For drivers that do not support the | |
2891 | * controller or are already connected | |
2892 | * we receive an error code here. | |
2893 | */ | |
2894 | if (r == EFI_SUCCESS) | |
2895 | ++connected; | |
2896 | } | |
2897 | } | |
2898 | } | |
2899 | } | |
2900 | ||
2901 | /* | |
2902 | * TODO: Some overrides are not yet implemented: | |
2903 | * - Platform Driver Override | |
2904 | * - Driver Family Override Search | |
2905 | * - Bus Specific Driver Override | |
2906 | */ | |
2907 | ||
2908 | /* Driver Binding Search */ | |
2909 | for (i = 0; i < count; ++i) { | |
2910 | if (buffer[i]) { | |
2911 | r = efi_bind_controller(controller_handle, | |
2912 | buffer[i], | |
2913 | remain_device_path); | |
2914 | if (r == EFI_SUCCESS) | |
2915 | ++connected; | |
2916 | } | |
2917 | } | |
2918 | ||
2919 | efi_free_pool(buffer); | |
2920 | if (!connected) | |
2921 | return EFI_NOT_FOUND; | |
2922 | return EFI_SUCCESS; | |
2923 | } | |
2924 | ||
6b03cd10 | 2925 | /** |
78a88f79 MS |
2926 | * efi_connect_controller() - connect a controller to a driver |
2927 | * @controller_handle: handle of the controller | |
2928 | * @driver_image_handle: handle of the driver | |
2929 | * @remain_device_path: device path of a child controller | |
2930 | * @recursive: true to connect all child controllers | |
f0959dbe HS |
2931 | * |
2932 | * This function implements the ConnectController service. | |
78a88f79 MS |
2933 | * |
2934 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
2935 | * details. | |
f0959dbe HS |
2936 | * |
2937 | * First all driver binding protocol handles are tried for binding drivers. | |
b72aaa87 | 2938 | * Afterwards all handles that have opened a protocol of the controller |
f0959dbe HS |
2939 | * with EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER are connected to drivers. |
2940 | * | |
78a88f79 | 2941 | * Return: status code |
f0959dbe HS |
2942 | */ |
2943 | static efi_status_t EFIAPI efi_connect_controller( | |
2944 | efi_handle_t controller_handle, | |
2945 | efi_handle_t *driver_image_handle, | |
2946 | struct efi_device_path *remain_device_path, | |
2947 | bool recursive) | |
2948 | { | |
2949 | efi_status_t r; | |
2950 | efi_status_t ret = EFI_NOT_FOUND; | |
2951 | struct efi_object *efiobj; | |
2952 | ||
d178836b | 2953 | EFI_ENTRY("%p, %p, %pD, %d", controller_handle, driver_image_handle, |
f0959dbe HS |
2954 | remain_device_path, recursive); |
2955 | ||
2956 | efiobj = efi_search_obj(controller_handle); | |
2957 | if (!efiobj) { | |
2958 | ret = EFI_INVALID_PARAMETER; | |
2959 | goto out; | |
2960 | } | |
2961 | ||
2962 | r = efi_connect_single_controller(controller_handle, | |
2963 | driver_image_handle, | |
2964 | remain_device_path); | |
2965 | if (r == EFI_SUCCESS) | |
2966 | ret = EFI_SUCCESS; | |
2967 | if (recursive) { | |
2968 | struct efi_handler *handler; | |
2969 | struct efi_open_protocol_info_item *item; | |
2970 | ||
2971 | list_for_each_entry(handler, &efiobj->protocols, link) { | |
2972 | list_for_each_entry(item, &handler->open_infos, link) { | |
2973 | if (item->info.attributes & | |
2974 | EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) { | |
2975 | r = EFI_CALL(efi_connect_controller( | |
2976 | item->info.controller_handle, | |
2977 | driver_image_handle, | |
2978 | remain_device_path, | |
2979 | recursive)); | |
2980 | if (r == EFI_SUCCESS) | |
2981 | ret = EFI_SUCCESS; | |
2982 | } | |
2983 | } | |
2984 | } | |
2985 | } | |
2986 | /* Check for child controller specified by end node */ | |
2987 | if (ret != EFI_SUCCESS && remain_device_path && | |
2988 | remain_device_path->type == DEVICE_PATH_TYPE_END) | |
2989 | ret = EFI_SUCCESS; | |
2990 | out: | |
2991 | return EFI_EXIT(ret); | |
2992 | } | |
2993 | ||
6b03cd10 | 2994 | /** |
78a88f79 MS |
2995 | * efi_reinstall_protocol_interface() - reinstall protocol interface |
2996 | * @handle: handle on which the protocol shall be reinstalled | |
2997 | * @protocol: GUID of the protocol to be installed | |
2998 | * @old_interface: interface to be removed | |
2999 | * @new_interface: interface to be installed | |
e861a120 HS |
3000 | * |
3001 | * This function implements the ReinstallProtocolInterface service. | |
78a88f79 MS |
3002 | * |
3003 | * See the Unified Extensible Firmware Interface (UEFI) specification for | |
3004 | * details. | |
e861a120 HS |
3005 | * |
3006 | * The old interface is uninstalled. The new interface is installed. | |
3007 | * Drivers are connected. | |
3008 | * | |
78a88f79 | 3009 | * Return: status code |
e861a120 HS |
3010 | */ |
3011 | static efi_status_t EFIAPI efi_reinstall_protocol_interface( | |
3012 | efi_handle_t handle, const efi_guid_t *protocol, | |
3013 | void *old_interface, void *new_interface) | |
3014 | { | |
3015 | efi_status_t ret; | |
3016 | ||
3017 | EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, old_interface, | |
3018 | new_interface); | |
9b47f13b HS |
3019 | |
3020 | /* Uninstall protocol but do not delete handle */ | |
3021 | ret = efi_uninstall_protocol(handle, protocol, old_interface); | |
e861a120 HS |
3022 | if (ret != EFI_SUCCESS) |
3023 | goto out; | |
9b47f13b HS |
3024 | |
3025 | /* Install the new protocol */ | |
3026 | ret = efi_add_protocol(handle, protocol, new_interface); | |
3027 | /* | |
3028 | * The UEFI spec does not specify what should happen to the handle | |
3029 | * if in case of an error no protocol interface remains on the handle. | |
3030 | * So let's do nothing here. | |
3031 | */ | |
e861a120 HS |
3032 | if (ret != EFI_SUCCESS) |
3033 | goto out; | |
3034 | /* | |
3035 | * The returned status code has to be ignored. | |
3036 | * Do not create an error if no suitable driver for the handle exists. | |
3037 | */ | |
3038 | EFI_CALL(efi_connect_controller(handle, NULL, NULL, true)); | |
3039 | out: | |
3040 | return EFI_EXIT(ret); | |
3041 | } | |
3042 | ||
6b03cd10 | 3043 | /** |
78a88f79 MS |
3044 | * efi_get_child_controllers() - get all child controllers associated to a driver |
3045 | * @efiobj: handle of the controller | |
3046 | * @driver_handle: handle of the driver | |
3047 | * @number_of_children: number of child controllers | |
3048 | * @child_handle_buffer: handles of the the child controllers | |
6b03cd10 | 3049 | * |
3f9b0042 HS |
3050 | * The allocated buffer has to be freed with free(). |
3051 | * | |
78a88f79 | 3052 | * Return: status code |
3f9b0042 HS |
3053 | */ |
3054 | static efi_status_t efi_get_child_controllers( | |
3055 | struct efi_object *efiobj, | |
3056 | efi_handle_t driver_handle, | |
3057 | efi_uintn_t *number_of_children, | |
3058 | efi_handle_t **child_handle_buffer) | |
3059 | { | |
3060 | struct efi_handler *handler; | |
3061 | struct efi_open_protocol_info_item *item; | |
3062 | efi_uintn_t count = 0, i; | |
3063 | bool duplicate; | |
3064 | ||
3065 | /* Count all child controller associations */ | |
3066 | list_for_each_entry(handler, &efiobj->protocols, link) { | |
3067 | list_for_each_entry(item, &handler->open_infos, link) { | |
3068 | if (item->info.agent_handle == driver_handle && | |
3069 | item->info.attributes & | |
3070 | EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) | |
3071 | ++count; | |
3072 | } | |
3073 | } | |
3074 | /* | |
3075 | * Create buffer. In case of duplicate child controller assignments | |
3076 | * the buffer will be too large. But that does not harm. | |
3077 | */ | |
3078 | *number_of_children = 0; | |
3079 | *child_handle_buffer = calloc(count, sizeof(efi_handle_t)); | |
3080 | if (!*child_handle_buffer) | |
3081 | return EFI_OUT_OF_RESOURCES; | |
3082 | /* Copy unique child handles */ | |
3083 | list_for_each_entry(handler, &efiobj->protocols, link) { | |
3084 | list_for_each_entry(item, &handler->open_infos, link) { | |
3085 | if (item->info.agent_handle == driver_handle && | |
3086 | item->info.attributes & | |
3087 | EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) { | |
3088 | /* Check this is a new child controller */ | |
3089 | duplicate = false; | |
3090 | for (i = 0; i < *number_of_children; ++i) { | |
3091 | if ((*child_handle_buffer)[i] == | |
3092 | item->info.controller_handle) | |
3093 | duplicate = true; | |
3094 | } | |
3095 | /* Copy handle to buffer */ | |
3096 | if (!duplicate) { | |
3097 | i = (*number_of_children)++; | |
3098 | (*child_handle_buffer)[i] = | |
3099 | item->info.controller_handle; | |
3100 | } | |
3101 | } | |
3102 | } | |
3103 | } | |
3104 | return EFI_SUCCESS; | |
3105 | } | |
3106 | ||
6b03cd10 | 3107 | /** |
78a88f79 MS |
3108 | * efi_disconnect_controller() - disconnect a controller from a driver |
3109 | * @controller_handle: handle of the controller | |
3110 | * @driver_image_handle: handle of the driver | |
3111 | * @child_handle: handle of the child to destroy | |
3f9b0042 HS |
3112 | * |
3113 | * This function implements the DisconnectController service. | |
3f9b0042 | 3114 | * |
78a88f79 MS |
3115 | * See the Unified Extensible Firmware Interface (UEFI) specification for |
3116 | * details. | |
3117 | * | |
3118 | * Return: status code | |
3f9b0042 HS |
3119 | */ |
3120 | static efi_status_t EFIAPI efi_disconnect_controller( | |
3121 | efi_handle_t controller_handle, | |
3122 | efi_handle_t driver_image_handle, | |
3123 | efi_handle_t child_handle) | |
3124 | { | |
3125 | struct efi_driver_binding_protocol *binding_protocol; | |
3126 | efi_handle_t *child_handle_buffer = NULL; | |
3127 | size_t number_of_children = 0; | |
3128 | efi_status_t r; | |
3129 | size_t stop_count = 0; | |
3130 | struct efi_object *efiobj; | |
3131 | ||
3132 | EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle, | |
3133 | child_handle); | |
3134 | ||
3135 | efiobj = efi_search_obj(controller_handle); | |
3136 | if (!efiobj) { | |
3137 | r = EFI_INVALID_PARAMETER; | |
3138 | goto out; | |
3139 | } | |
3140 | ||
3141 | if (child_handle && !efi_search_obj(child_handle)) { | |
3142 | r = EFI_INVALID_PARAMETER; | |
3143 | goto out; | |
3144 | } | |
3145 | ||
3146 | /* If no driver handle is supplied, disconnect all drivers */ | |
3147 | if (!driver_image_handle) { | |
3148 | r = efi_disconnect_all_drivers(efiobj, NULL, child_handle); | |
3149 | goto out; | |
3150 | } | |
3151 | ||
3152 | /* Create list of child handles */ | |
3153 | if (child_handle) { | |
3154 | number_of_children = 1; | |
3155 | child_handle_buffer = &child_handle; | |
3156 | } else { | |
3157 | efi_get_child_controllers(efiobj, | |
3158 | driver_image_handle, | |
3159 | &number_of_children, | |
3160 | &child_handle_buffer); | |
3161 | } | |
3162 | ||
3163 | /* Get the driver binding protocol */ | |
3164 | r = EFI_CALL(efi_open_protocol(driver_image_handle, | |
3165 | &efi_guid_driver_binding_protocol, | |
3166 | (void **)&binding_protocol, | |
3167 | driver_image_handle, NULL, | |
3168 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
3169 | if (r != EFI_SUCCESS) | |
3170 | goto out; | |
3171 | /* Remove the children */ | |
3172 | if (number_of_children) { | |
3173 | r = EFI_CALL(binding_protocol->stop(binding_protocol, | |
3174 | controller_handle, | |
3175 | number_of_children, | |
3176 | child_handle_buffer)); | |
3177 | if (r == EFI_SUCCESS) | |
3178 | ++stop_count; | |
3179 | } | |
3180 | /* Remove the driver */ | |
3181 | if (!child_handle) | |
3182 | r = EFI_CALL(binding_protocol->stop(binding_protocol, | |
3183 | controller_handle, | |
3184 | 0, NULL)); | |
3185 | if (r == EFI_SUCCESS) | |
3186 | ++stop_count; | |
3187 | EFI_CALL(efi_close_protocol(driver_image_handle, | |
3188 | &efi_guid_driver_binding_protocol, | |
3189 | driver_image_handle, NULL)); | |
3190 | ||
3191 | if (stop_count) | |
3192 | r = EFI_SUCCESS; | |
3193 | else | |
3194 | r = EFI_NOT_FOUND; | |
3195 | out: | |
3196 | if (!child_handle) | |
3197 | free(child_handle_buffer); | |
3198 | return EFI_EXIT(r); | |
3199 | } | |
3200 | ||
640adadf | 3201 | static struct efi_boot_services efi_boot_services = { |
bee91169 | 3202 | .hdr = { |
112f2430 HS |
3203 | .signature = EFI_BOOT_SERVICES_SIGNATURE, |
3204 | .revision = EFI_SPECIFICATION_VERSION, | |
71c846ab | 3205 | .headersize = sizeof(struct efi_boot_services), |
bee91169 AG |
3206 | }, |
3207 | .raise_tpl = efi_raise_tpl, | |
3208 | .restore_tpl = efi_restore_tpl, | |
3209 | .allocate_pages = efi_allocate_pages_ext, | |
3210 | .free_pages = efi_free_pages_ext, | |
3211 | .get_memory_map = efi_get_memory_map_ext, | |
ead1274b | 3212 | .allocate_pool = efi_allocate_pool_ext, |
42417bc8 | 3213 | .free_pool = efi_free_pool_ext, |
49deb455 | 3214 | .create_event = efi_create_event_ext, |
bfc72462 | 3215 | .set_timer = efi_set_timer_ext, |
bee91169 | 3216 | .wait_for_event = efi_wait_for_event, |
c6841592 | 3217 | .signal_event = efi_signal_event_ext, |
bee91169 AG |
3218 | .close_event = efi_close_event, |
3219 | .check_event = efi_check_event, | |
1760ef57 | 3220 | .install_protocol_interface = efi_install_protocol_interface, |
bee91169 | 3221 | .reinstall_protocol_interface = efi_reinstall_protocol_interface, |
cd534083 | 3222 | .uninstall_protocol_interface = efi_uninstall_protocol_interface, |
bee91169 AG |
3223 | .handle_protocol = efi_handle_protocol, |
3224 | .reserved = NULL, | |
3225 | .register_protocol_notify = efi_register_protocol_notify, | |
26329584 | 3226 | .locate_handle = efi_locate_handle_ext, |
bee91169 | 3227 | .locate_device_path = efi_locate_device_path, |
488bf12d | 3228 | .install_configuration_table = efi_install_configuration_table_ext, |
bee91169 AG |
3229 | .load_image = efi_load_image, |
3230 | .start_image = efi_start_image, | |
a86aeaf2 | 3231 | .exit = efi_exit, |
bee91169 AG |
3232 | .unload_image = efi_unload_image, |
3233 | .exit_boot_services = efi_exit_boot_services, | |
3234 | .get_next_monotonic_count = efi_get_next_monotonic_count, | |
3235 | .stall = efi_stall, | |
3236 | .set_watchdog_timer = efi_set_watchdog_timer, | |
3237 | .connect_controller = efi_connect_controller, | |
3238 | .disconnect_controller = efi_disconnect_controller, | |
3239 | .open_protocol = efi_open_protocol, | |
3240 | .close_protocol = efi_close_protocol, | |
3241 | .open_protocol_information = efi_open_protocol_information, | |
3242 | .protocols_per_handle = efi_protocols_per_handle, | |
3243 | .locate_handle_buffer = efi_locate_handle_buffer, | |
3244 | .locate_protocol = efi_locate_protocol, | |
ab9efa97 HS |
3245 | .install_multiple_protocol_interfaces = |
3246 | efi_install_multiple_protocol_interfaces, | |
3247 | .uninstall_multiple_protocol_interfaces = | |
3248 | efi_uninstall_multiple_protocol_interfaces, | |
bee91169 AG |
3249 | .calculate_crc32 = efi_calculate_crc32, |
3250 | .copy_mem = efi_copy_mem, | |
3251 | .set_mem = efi_set_mem, | |
9f0930e5 | 3252 | .create_event_ex = efi_create_event_ex, |
bee91169 AG |
3253 | }; |
3254 | ||
0b386537 | 3255 | static u16 __efi_runtime_data firmware_vendor[] = L"Das U-Boot"; |
bee91169 | 3256 | |
3c63db9c | 3257 | struct efi_system_table __efi_runtime_data systab = { |
bee91169 AG |
3258 | .hdr = { |
3259 | .signature = EFI_SYSTEM_TABLE_SIGNATURE, | |
112f2430 | 3260 | .revision = EFI_SPECIFICATION_VERSION, |
71c846ab | 3261 | .headersize = sizeof(struct efi_system_table), |
bee91169 | 3262 | }, |
0b386537 HS |
3263 | .fw_vendor = firmware_vendor, |
3264 | .fw_revision = FW_VERSION << 16 | FW_PATCHLEVEL << 8, | |
ab9efa97 HS |
3265 | .con_in = (void *)&efi_con_in, |
3266 | .con_out = (void *)&efi_con_out, | |
3267 | .std_err = (void *)&efi_con_out, | |
3268 | .runtime = (void *)&efi_runtime_services, | |
3269 | .boottime = (void *)&efi_boot_services, | |
bee91169 | 3270 | .nr_tables = 0, |
4182a129 | 3271 | .tables = NULL, |
bee91169 | 3272 | }; |
640adadf HS |
3273 | |
3274 | /** | |
3275 | * efi_initialize_system_table() - Initialize system table | |
3276 | * | |
0414359a | 3277 | * Return: status code |
640adadf HS |
3278 | */ |
3279 | efi_status_t efi_initialize_system_table(void) | |
3280 | { | |
4182a129 HS |
3281 | efi_status_t ret; |
3282 | ||
3283 | /* Allocate configuration table array */ | |
3284 | ret = efi_allocate_pool(EFI_RUNTIME_SERVICES_DATA, | |
3285 | EFI_MAX_CONFIGURATION_TABLES * | |
3286 | sizeof(struct efi_configuration_table), | |
3287 | (void **)&systab.tables); | |
3288 | ||
b72aaa87 | 3289 | /* Set CRC32 field in table headers */ |
640adadf HS |
3290 | efi_update_table_header_crc32(&systab.hdr); |
3291 | efi_update_table_header_crc32(&efi_runtime_services.hdr); | |
3292 | efi_update_table_header_crc32(&efi_boot_services.hdr); | |
4182a129 HS |
3293 | |
3294 | return ret; | |
640adadf | 3295 | } |