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