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