tablet/grub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

efi: Drop all uses of efi_call_XX() wrappers

Browse Source 
Now that GCC can generate function calls using the correct calling
convention for us, we can stop using the efi_call_XX() wrappers, and
just dereference the function pointers directly.

This avoids the untyped variadic wrapper routines, which means better
type checking for the method calls.

Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
This commit is contained in:
Ard Biesheuvel 2023-05-23 17:31:43 +02:00 committed by Daniel Kiper
parent 6a080b9cde
commit bb4aa6e06e
23 changed files with 165 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
grub-core/commands/acpi.c
View File

@ -762,10 +762,10 @@ grub_cmd_acpi (struct grub_extcmd_context *ctxt, int argc, char **args)
struct grub_efi_guid acpi = GRUB_EFI_ACPI_TABLE_GUID; struct grub_efi_guid acpi = GRUB_EFI_ACPI_TABLE_GUID;
struct grub_efi_guid acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID; struct grub_efi_guid acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID;
efi_call_2 (grub_efi_system_table->boot_services->install_configuration_table, grub_efi_system_table->boot_services->install_configuration_table (&acpi20,
&acpi20, grub_acpi_get_rsdpv2 ()); grub_acpi_get_rsdpv2 ());
efi_call_2 (grub_efi_system_table->boot_services->install_configuration_table, grub_efi_system_table->boot_services->install_configuration_table (&acpi,
&acpi, grub_acpi_get_rsdpv1 ()); grub_acpi_get_rsdpv1 ());
} }
#endif #endif

8
grub-core/commands/efi/efitextmode.c
View File

@ -36,7 +36,7 @@ grub_efi_set_mode (grub_efi_simple_text_output_interface_t *o,
if (mode != o->mode->mode) if (mode != o->mode->mode)
{ {
status = efi_call_2 (o->set_mode, o, mode); status = o->set_mode (o, mode);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
; ;
else if (status == GRUB_EFI_DEVICE_ERROR) else if (status == GRUB_EFI_DEVICE_ERROR)
@ -79,8 +79,7 @@ grub_cmd_efitextmode (grub_command_t cmd __attribute__ ((unused)),
grub_printf_ (N_("Available modes for console output device.\n")); grub_printf_ (N_("Available modes for console output device.\n"));
for (i = 0; i < o->mode->max_mode; i++) for (i = 0; i < o->mode->max_mode; i++)
if (GRUB_EFI_SUCCESS == efi_call_4 (o->query_mode, o, i, if (GRUB_EFI_SUCCESS == o->query_mode (o, i, &columns, &rows))
&columns, &rows))
grub_printf_ (N_(" [%" PRIuGRUB_EFI_UINT32_T "] Col %5" grub_printf_ (N_(" [%" PRIuGRUB_EFI_UINT32_T "] Col %5"
PRIuGRUB_EFI_UINTN_T " Row %5" PRIuGRUB_EFI_UINTN_T PRIuGRUB_EFI_UINTN_T " Row %5" PRIuGRUB_EFI_UINTN_T
" %c\n"), " %c\n"),
@ -129,8 +128,7 @@ grub_cmd_efitextmode (grub_command_t cmd __attribute__ ((unused)),
N_("non-numeric or invalid rows number `%s'"), args[1]); N_("non-numeric or invalid rows number `%s'"), args[1]);
for (i = 0; i < o->mode->max_mode; i++) for (i = 0; i < o->mode->max_mode; i++)
if (GRUB_EFI_SUCCESS == efi_call_4 (o->query_mode, o, i, if (GRUB_EFI_SUCCESS == o->query_mode (o, i, &columns, &rows))
&columns, &rows))
if (u_columns == columns && u_rows == rows) if (u_columns == columns && u_rows == rows)
return grub_efi_set_mode (o, (grub_efi_int32_t) i); return grub_efi_set_mode (o, (grub_efi_int32_t) i);

5
grub-core/commands/efi/lsefi.c
View File

@ -108,8 +108,9 @@ grub_cmd_lsefi (grub_command_t cmd __attribute__ ((unused)),
grub_efi_print_device_path (dp); grub_efi_print_device_path (dp);
} }
status = efi_call_3 (grub_efi_system_table->boot_services->protocols_per_handle, status = grub_efi_system_table->boot_services->protocols_per_handle (handle,
handle, &protocols, &num_protocols); &protocols,
&num_protocols);
if (status != GRUB_EFI_SUCCESS) { if (status != GRUB_EFI_SUCCESS) {
grub_printf ("Unable to retrieve protocols\n"); grub_printf ("Unable to retrieve protocols\n");
continue; continue;

21
grub-core/commands/efi/tpm.c
View File

@ -53,8 +53,7 @@ grub_tpm1_present (grub_efi_tpm_protocol_t *tpm)
caps.Size = (grub_uint8_t) sizeof (caps); caps.Size = (grub_uint8_t) sizeof (caps);
status = efi_call_5 (tpm->status_check, tpm, &caps, &flags, &eventlog, status = tpm->status_check (tpm, &caps, &flags, &eventlog, &lastevent);
&lastevent);
if (status != GRUB_EFI_SUCCESS || caps.TPMDeactivatedFlag if (status != GRUB_EFI_SUCCESS || caps.TPMDeactivatedFlag
|| !caps.TPMPresentFlag) || !caps.TPMPresentFlag)
@ -78,7 +77,7 @@ grub_tpm2_present (grub_efi_tpm2_protocol_t *tpm)
if (tpm2_present != -1) if (tpm2_present != -1)
return (grub_efi_boolean_t) tpm2_present; return (grub_efi_boolean_t) tpm2_present;
status = efi_call_2 (tpm->get_capability, tpm, &caps); status = tpm->get_capability (tpm, &caps);
if (status != GRUB_EFI_SUCCESS || !caps.TPMPresentFlag) if (status != GRUB_EFI_SUCCESS || !caps.TPMPresentFlag)
tpm2_present = 0; tpm2_present = 0;
@ -180,8 +179,8 @@ grub_tpm1_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
grub_strcpy ((char *) event->Event, description); grub_strcpy ((char *) event->Event, description);
algorithm = TCG_ALG_SHA; algorithm = TCG_ALG_SHA;
status = efi_call_7 (tpm->log_extend_event, tpm, (grub_addr_t) buf, (grub_uint64_t) size, status = tpm->log_extend_event (tpm, (grub_addr_t) buf, (grub_uint64_t) size,
algorithm, event, &eventnum, &lastevent); algorithm, event, &eventnum, &lastevent);
grub_free (event); grub_free (event);
return grub_efi_log_event_status (status); return grub_efi_log_event_status (status);
@ -216,8 +215,8 @@ grub_tpm2_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
sizeof (*event) - sizeof (event->Event) + grub_strlen (description) + 1; sizeof (*event) - sizeof (event->Event) + grub_strlen (description) + 1;
grub_strcpy ((char *) event->Event, description); grub_strcpy ((char *) event->Event, description);
status = efi_call_5 (tpm->hash_log_extend_event, tpm, 0, (grub_addr_t) buf, status = tpm->hash_log_extend_event (tpm, 0, (grub_addr_t) buf,
(grub_uint64_t) size, event); (grub_uint64_t) size, event);
grub_free (event); grub_free (event);
return grub_efi_log_event_status (status); return grub_efi_log_event_status (status);
@ -236,7 +235,7 @@ grub_cc_log_event (unsigned char *buf, grub_size_t size, grub_uint8_t pcr,
if (cc == NULL) if (cc == NULL)
return; return;
status = efi_call_3 (cc->map_pcr_to_mr_index, cc, pcr, &mr); status = cc->map_pcr_to_mr_index (cc, pcr, &mr);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
grub_efi_log_event_status (status); grub_efi_log_event_status (status);
@ -258,9 +257,9 @@ grub_cc_log_event (unsigned char *buf, grub_size_t size, grub_uint8_t pcr,
event->Size = sizeof (*event) + grub_strlen (description) + 1; event->Size = sizeof (*event) + grub_strlen (description) + 1;
grub_strcpy ((char *) event->Event, description); grub_strcpy ((char *) event->Event, description);
status = efi_call_5 (cc->hash_log_extend_event, cc, 0, status = cc->hash_log_extend_event (cc, 0,
(grub_efi_physical_address_t)(grub_addr_t) buf, (grub_efi_physical_address_t)(grub_addr_t) buf,
(grub_efi_uint64_t) size, event); (grub_efi_uint64_t) size, event);
grub_free (event); grub_free (event);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)

7
grub-core/disk/efi/efidisk.c
View File

@ -579,9 +579,10 @@ grub_efidisk_readwrite (struct grub_disk *disk, grub_disk_addr_t sector,
aligned_buf = buf; aligned_buf = buf;
} }
status = efi_call_5 ((wr ? bio->write_blocks : bio->read_blocks), bio, status = (wr ? bio->write_blocks : bio->read_blocks) (bio, bio->media->media_id,
bio->media->media_id, (grub_efi_uint64_t) sector, (grub_efi_uint64_t) sector,
(grub_efi_uintn_t) num_bytes, aligned_buf); (grub_efi_uintn_t) num_bytes,
aligned_buf);
if ((grub_addr_t) buf & (io_align - 1)) if ((grub_addr_t) buf & (io_align - 1))
{ {

10
grub-core/kern/arm/efi/init.c
View File

@ -50,9 +50,9 @@ grub_machine_init (void)
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_5 (b->create_event, GRUB_EFI_EVT_TIMER | GRUB_EFI_EVT_NOTIFY_SIGNAL, b->create_event (GRUB_EFI_EVT_TIMER | GRUB_EFI_EVT_NOTIFY_SIGNAL,
GRUB_EFI_TPL_CALLBACK, increment_timer, NULL, &tmr_evt); GRUB_EFI_TPL_CALLBACK, increment_timer, NULL, &tmr_evt);
efi_call_3 (b->set_timer, tmr_evt, GRUB_EFI_TIMER_PERIODIC, 100000); b->set_timer (tmr_evt, GRUB_EFI_TIMER_PERIODIC, 100000);
grub_install_get_time_ms (grub_efi_get_time_ms); grub_install_get_time_ms (grub_efi_get_time_ms);
} }
@ -67,8 +67,8 @@ grub_machine_fini (int flags)
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_3 (b->set_timer, tmr_evt, GRUB_EFI_TIMER_CANCEL, 0); b->set_timer (tmr_evt, GRUB_EFI_TIMER_CANCEL, 0);
efi_call_1 (b->close_event, tmr_evt); b->close_event (tmr_evt);
grub_efi_fini (); grub_efi_fini ();

56
grub-core/kern/efi/efi.c
View File

@ -45,8 +45,9 @@ grub_efi_locate_protocol (grub_efi_guid_t *protocol, void *registration)
void *interface; void *interface;
grub_efi_status_t status; grub_efi_status_t status;
status = efi_call_3 (grub_efi_system_table->boot_services->locate_protocol, status = grub_efi_system_table->boot_services->locate_protocol (protocol,
protocol, registration, &interface); registration,
&interface);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return 0; return 0;
@ -72,7 +73,7 @@ grub_efi_locate_handle (grub_efi_locate_search_type_t search_type,
return 0; return 0;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_5 (b->locate_handle, search_type, protocol, search_key, status = b->locate_handle (search_type, protocol, search_key,
&buffer_size, buffer); &buffer_size, buffer);
if (status == GRUB_EFI_BUFFER_TOO_SMALL) if (status == GRUB_EFI_BUFFER_TOO_SMALL)
{ {
@ -81,7 +82,7 @@ grub_efi_locate_handle (grub_efi_locate_search_type_t search_type,
if (! buffer) if (! buffer)
return 0; return 0;
status = efi_call_5 (b->locate_handle, search_type, protocol, search_key, status = b->locate_handle (search_type, protocol, search_key,
&buffer_size, buffer); &buffer_size, buffer);
} }
@ -105,12 +106,12 @@ grub_efi_open_protocol (grub_efi_handle_t handle,
void *interface; void *interface;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_6 (b->open_protocol, handle, status = b->open_protocol (handle,
protocol, protocol,
&interface, &interface,
grub_efi_image_handle, grub_efi_image_handle,
0, 0,
attributes); attributes);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return 0; return 0;
@ -122,7 +123,7 @@ grub_efi_close_protocol (grub_efi_handle_t handle, grub_efi_guid_t *protocol)
{ {
grub_efi_boot_services_t *b = grub_efi_system_table->boot_services; grub_efi_boot_services_t *b = grub_efi_system_table->boot_services;
return efi_call_4 (b->close_protocol, handle, protocol, grub_efi_image_handle, NULL); return b->close_protocol (handle, protocol, grub_efi_image_handle, NULL);
} }
int int
@ -137,12 +138,12 @@ grub_efi_set_text_mode (int on)
already in text mode. */ already in text mode. */
return 1; return 1;
if (efi_call_4 (c->get_mode, c, &mode, 0, 0) != GRUB_EFI_SUCCESS) if (c->get_mode (c, &mode, 0, 0) != GRUB_EFI_SUCCESS)
return 0; return 0;
new_mode = on ? GRUB_EFI_SCREEN_TEXT : GRUB_EFI_SCREEN_GRAPHICS; new_mode = on ? GRUB_EFI_SCREEN_TEXT : GRUB_EFI_SCREEN_GRAPHICS;
if (mode != new_mode) if (mode != new_mode)
if (efi_call_2 (c->set_mode, c, new_mode) != GRUB_EFI_SUCCESS) if (c->set_mode (c, new_mode) != GRUB_EFI_SUCCESS)
return 0; return 0;
return 1; return 1;
@ -151,7 +152,7 @@ grub_efi_set_text_mode (int on)
void void
grub_efi_stall (grub_efi_uintn_t microseconds) grub_efi_stall (grub_efi_uintn_t microseconds)
{ {
efi_call_1 (grub_efi_system_table->boot_services->stall, microseconds); grub_efi_system_table->boot_services->stall (microseconds);
} }
grub_efi_loaded_image_t * grub_efi_loaded_image_t *
@ -167,8 +168,9 @@ grub_reboot (void)
{ {
grub_machine_fini (GRUB_LOADER_FLAG_NORETURN | grub_machine_fini (GRUB_LOADER_FLAG_NORETURN |
GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY); GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY);
efi_call_4 (grub_efi_system_table->runtime_services->reset_system, grub_efi_system_table->runtime_services->reset_system (GRUB_EFI_RESET_COLD,
GRUB_EFI_RESET_COLD, GRUB_EFI_SUCCESS, 0, NULL); GRUB_EFI_SUCCESS, 0,
NULL);
for (;;) ; for (;;) ;
} }
@ -176,8 +178,8 @@ void
grub_exit (void) grub_exit (void)
{ {
grub_machine_fini (GRUB_LOADER_FLAG_NORETURN); grub_machine_fini (GRUB_LOADER_FLAG_NORETURN);
efi_call_4 (grub_efi_system_table->boot_services->exit, grub_efi_system_table->boot_services->exit (grub_efi_image_handle,
grub_efi_image_handle, GRUB_EFI_SUCCESS, 0, 0); GRUB_EFI_SUCCESS, 0, 0);
for (;;) ; for (;;) ;
} }
@ -191,8 +193,8 @@ grub_efi_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
grub_efi_status_t status; grub_efi_status_t status;
r = grub_efi_system_table->runtime_services; r = grub_efi_system_table->runtime_services;
status = efi_call_4 (r->set_virtual_address_map, memory_map_size, status = r->set_virtual_address_map (memory_map_size, descriptor_size,
descriptor_size, descriptor_version, virtual_map); descriptor_version, virtual_map);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
@ -219,11 +221,11 @@ grub_efi_set_variable(const char *var, const grub_efi_guid_t *guid,
r = grub_efi_system_table->runtime_services; r = grub_efi_system_table->runtime_services;
status = efi_call_5 (r->set_variable, var16, guid, status = r->set_variable (var16, guid,
(GRUB_EFI_VARIABLE_NON_VOLATILE (GRUB_EFI_VARIABLE_NON_VOLATILE
| GRUB_EFI_VARIABLE_BOOTSERVICE_ACCESS | GRUB_EFI_VARIABLE_BOOTSERVICE_ACCESS
| GRUB_EFI_VARIABLE_RUNTIME_ACCESS), | GRUB_EFI_VARIABLE_RUNTIME_ACCESS),
datasize, data); datasize, data);
grub_free (var16); grub_free (var16);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
@ -258,7 +260,7 @@ grub_efi_get_variable_with_attributes (const char *var,
r = grub_efi_system_table->runtime_services; r = grub_efi_system_table->runtime_services;
status = efi_call_5 (r->get_variable, var16, guid, NULL, &datasize, NULL); status = r->get_variable (var16, guid, NULL, &datasize, NULL);
if (status != GRUB_EFI_BUFFER_TOO_SMALL || !datasize) if (status != GRUB_EFI_BUFFER_TOO_SMALL || !datasize)
{ {
@ -273,7 +275,7 @@ grub_efi_get_variable_with_attributes (const char *var,
return GRUB_EFI_OUT_OF_RESOURCES; return GRUB_EFI_OUT_OF_RESOURCES;
} }
status = efi_call_5 (r->get_variable, var16, guid, attributes, &datasize, data); status = r->get_variable (var16, guid, attributes, &datasize, data);
grub_free (var16); grub_free (var16);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)

15
grub-core/kern/efi/init.c
View File

@ -56,11 +56,11 @@ __stack_chk_fail (void)
* the serial console, at least on EDK2. * the serial console, at least on EDK2.
*/ */
o = grub_efi_system_table->con_out; o = grub_efi_system_table->con_out;
efi_call_2 (o->output_string, o, stack_chk_fail_msg); o->output_string (o, stack_chk_fail_msg);
efi_call_1 (grub_efi_system_table->boot_services->stall, 5000000); grub_efi_system_table->boot_services->stall (5000000);
efi_call_4 (grub_efi_system_table->runtime_services->reset_system, grub_efi_system_table->runtime_services->reset_system (GRUB_EFI_RESET_SHUTDOWN,
GRUB_EFI_RESET_SHUTDOWN, GRUB_EFI_ABORTED, 0, NULL); GRUB_EFI_ABORTED, 0, NULL);
/* /*
* We shouldn't get here. It's unsafe to return because the stack * We shouldn't get here. It's unsafe to return because the stack
@ -86,8 +86,8 @@ stack_protector_init (void)
{ {
grub_efi_status_t status; grub_efi_status_t status;
status = efi_call_4 (rng->get_rng, rng, NULL, sizeof (stack_chk_guard_buf), status = rng->get_rng (rng, NULL, sizeof (stack_chk_guard_buf),
stack_chk_guard_buf); stack_chk_guard_buf);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
grub_memcpy (&__stack_chk_guard, stack_chk_guard_buf, sizeof (__stack_chk_guard)); grub_memcpy (&__stack_chk_guard, stack_chk_guard_buf, sizeof (__stack_chk_guard));
} }
@ -124,8 +124,7 @@ grub_efi_init (void)
grub_shim_lock_verifier_setup (); grub_shim_lock_verifier_setup ();
} }
efi_call_4 (grub_efi_system_table->boot_services->set_watchdog_timer, grub_efi_system_table->boot_services->set_watchdog_timer (0, 0, 0, NULL);
0, 0, 0, NULL);
grub_efidisk_init (); grub_efidisk_init ();
} }

17
grub-core/kern/efi/mm.c
View File

@ -69,8 +69,8 @@ grub_efi_store_alloc (grub_efi_physical_address_t address,
grub_efi_status_t status; grub_efi_status_t status;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_3 (b->allocate_pool, GRUB_EFI_LOADER_DATA, status = b->allocate_pool (GRUB_EFI_LOADER_DATA,
sizeof(*alloc), (void**)&alloc); sizeof(*alloc), (void**)&alloc);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
{ {
@ -105,7 +105,7 @@ grub_efi_drop_alloc (grub_efi_physical_address_t address,
efi_allocated_memory = ea->next; efi_allocated_memory = ea->next;
/* Then free the memory backing it. */ /* Then free the memory backing it. */
efi_call_1 (b->free_pool, ea); b->free_pool (ea);
/* And leave, we're done. */ /* And leave, we're done. */
break; break;
@ -137,7 +137,7 @@ grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
} }
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address); status = b->allocate_pages (alloctype, memtype, pages, &address);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory")); grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
@ -149,7 +149,7 @@ grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
/* Uggh, the address 0 was allocated... This is too annoying, /* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */ so reallocate another one. */
address = GRUB_EFI_MAX_USABLE_ADDRESS; address = GRUB_EFI_MAX_USABLE_ADDRESS;
status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address); status = b->allocate_pages (alloctype, memtype, pages, &address);
grub_efi_free_pages (0, pages); grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
@ -188,7 +188,7 @@ grub_efi_free_pages (grub_efi_physical_address_t address,
grub_efi_boot_services_t *b; grub_efi_boot_services_t *b;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_2 (b->free_pages, address, pages); b->free_pages (address, pages);
grub_efi_drop_alloc (address, pages); grub_efi_drop_alloc (address, pages);
} }
@ -267,8 +267,7 @@ grub_efi_finish_boot_services (grub_efi_uintn_t *outbuf_size, void *outbuf,
} }
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_2 (b->exit_boot_services, grub_efi_image_handle, status = b->exit_boot_services (grub_efi_image_handle, finish_key);
finish_key);
if (status == GRUB_EFI_SUCCESS) if (status == GRUB_EFI_SUCCESS)
break; break;
@ -381,7 +380,7 @@ grub_efi_get_memory_map (grub_efi_uintn_t *memory_map_size,
descriptor_size = &size; descriptor_size = &size;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_5 (b->get_memory_map, memory_map_size, memory_map, map_key, status = b->get_memory_map (memory_map_size, memory_map, map_key,
descriptor_size, descriptor_version); descriptor_size, descriptor_version);
if (*descriptor_size == 0) if (*descriptor_size == 0)
*descriptor_size = sizeof (grub_efi_memory_descriptor_t); *descriptor_size = sizeof (grub_efi_memory_descriptor_t);

2
grub-core/kern/i386/efi/tsc.c
View File

@ -33,7 +33,7 @@ grub_tsc_calibrate_from_efi (void)
grub_uint64_t start_tsc, end_tsc; grub_uint64_t start_tsc, end_tsc;
/* Use EFI Time Service to calibrate TSC */ /* Use EFI Time Service to calibrate TSC */
start_tsc = grub_get_tsc (); start_tsc = grub_get_tsc ();
efi_call_1 (grub_efi_system_table->boot_services->stall, 1000); grub_efi_system_table->boot_services->stall (1000);
end_tsc = grub_get_tsc (); end_tsc = grub_get_tsc ();
grub_tsc_rate = grub_divmod64 ((1ULL << 32), end_tsc - start_tsc, 0); grub_tsc_rate = grub_divmod64 ((1ULL << 32), end_tsc - start_tsc, 0);
return 1; return 1;

14
grub-core/kern/ia64/efi/init.c
View File

@ -51,16 +51,16 @@ grub_machine_init (void)
grub_efi_uintn_t idx; grub_efi_uintn_t idx;
grub_efi_init (); grub_efi_init ();
efi_call_5 (grub_efi_system_table->boot_services->create_event, grub_efi_system_table->boot_services->create_event (GRUB_EFI_EVT_TIMER,
GRUB_EFI_EVT_TIMER, GRUB_EFI_TPL_CALLBACK, 0, 0, &event); GRUB_EFI_TPL_CALLBACK,
0, 0, &event);
before = get_itc (); before = get_itc ();
efi_call_3 (grub_efi_system_table->boot_services->set_timer, event, grub_efi_system_table->boot_services->set_timer (event, GRUB_EFI_TIMER_RELATIVE,
GRUB_EFI_TIMER_RELATIVE, 200000); 200000);
efi_call_3 (grub_efi_system_table->boot_services->wait_for_event, 1, grub_efi_system_table->boot_services->wait_for_event (1, &event, &idx);
&event, &idx);
after = get_itc (); after = get_itc ();
efi_call_1 (grub_efi_system_table->boot_services->close_event, event); grub_efi_system_table->boot_services->close_event (event);
divisor = (after - before + 5) / 20; divisor = (after - before + 5) / 20;
if (divisor == 0) if (divisor == 0)
divisor = 800000; divisor = 800000;

10
grub-core/kern/loongarch64/efi/init.c
View File

@ -50,9 +50,9 @@ grub_machine_init (void)
grub_efi_init (); grub_efi_init ();
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_5 (b->create_event, GRUB_EFI_EVT_TIMER | GRUB_EFI_EVT_NOTIFY_SIGNAL, b->create_event (GRUB_EFI_EVT_TIMER | GRUB_EFI_EVT_NOTIFY_SIGNAL,
GRUB_EFI_TPL_CALLBACK, grub_loongson_increment_timer, NULL, &tmr_evt); GRUB_EFI_TPL_CALLBACK, grub_loongson_increment_timer, NULL, &tmr_evt);
efi_call_3 (b->set_timer, tmr_evt, GRUB_EFI_TIMER_PERIODIC, EFI_TIMER_PERIOD_MILLISECONDS(10)); b->set_timer (tmr_evt, GRUB_EFI_TIMER_PERIODIC, EFI_TIMER_PERIOD_MILLISECONDS(10));
grub_install_get_time_ms (grub_efi_get_time_ms); grub_install_get_time_ms (grub_efi_get_time_ms);
} }
@ -67,8 +67,8 @@ grub_machine_fini (int flags)
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_3 (b->set_timer, tmr_evt, GRUB_EFI_TIMER_CANCEL, 0); b->set_timer (tmr_evt, GRUB_EFI_TIMER_CANCEL, 0);
efi_call_1 (b->close_event, tmr_evt); b->close_event (tmr_evt);
grub_efi_fini (); grub_efi_fini ();

9
grub-core/lib/efi/datetime.c
View File

@ -32,8 +32,7 @@ grub_get_datetime (struct grub_datetime *datetime)
grub_efi_status_t status; grub_efi_status_t status;
struct grub_efi_time efi_time; struct grub_efi_time efi_time;
status = efi_call_2 (grub_efi_system_table->runtime_services->get_time, status = grub_efi_system_table->runtime_services->get_time (&efi_time, 0);
&efi_time, 0);
if (status) if (status)
return grub_error (GRUB_ERR_INVALID_COMMAND, return grub_error (GRUB_ERR_INVALID_COMMAND,
@ -57,8 +56,7 @@ grub_set_datetime (struct grub_datetime *datetime)
grub_efi_status_t status; grub_efi_status_t status;
struct grub_efi_time efi_time; struct grub_efi_time efi_time;
status = efi_call_2 (grub_efi_system_table->runtime_services->get_time, status = grub_efi_system_table->runtime_services->get_time (&efi_time, 0);
&efi_time, 0);
if (status) if (status)
return grub_error (GRUB_ERR_INVALID_COMMAND, return grub_error (GRUB_ERR_INVALID_COMMAND,
@ -71,8 +69,7 @@ grub_set_datetime (struct grub_datetime *datetime)
efi_time.minute = datetime->minute; efi_time.minute = datetime->minute;
efi_time.second = datetime->second; efi_time.second = datetime->second;
status = efi_call_1 (grub_efi_system_table->runtime_services->set_time, status = grub_efi_system_table->runtime_services->set_time (&efi_time);
&efi_time);
if (status) if (status)
return grub_error (GRUB_ERR_INVALID_COMMAND, return grub_error (GRUB_ERR_INVALID_COMMAND,

4
grub-core/lib/efi/halt.c
View File

@ -34,8 +34,8 @@ grub_halt (void)
!defined(__loongarch__) && !defined(__riscv) !defined(__loongarch__) && !defined(__riscv)
grub_acpi_halt (); grub_acpi_halt ();
#endif #endif
efi_call_4 (grub_efi_system_table->runtime_services->reset_system, grub_efi_system_table->runtime_services->reset_system (GRUB_EFI_RESET_SHUTDOWN,
GRUB_EFI_RESET_SHUTDOWN, GRUB_EFI_SUCCESS, 0, NULL); GRUB_EFI_SUCCESS, 0, NULL);
while (1); while (1);
} }

6
grub-core/lib/efi/relocator.c
View File

@ -101,8 +101,8 @@ grub_relocator_firmware_alloc_region (grub_addr_t start, grub_size_t size)
(unsigned long long) start, (unsigned long long) size); (unsigned long long) start, (unsigned long long) size);
#endif #endif
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ADDRESS, status = b->allocate_pages (GRUB_EFI_ALLOCATE_ADDRESS,
GRUB_EFI_LOADER_DATA, size >> 12, &address); GRUB_EFI_LOADER_DATA, size >> 12, &address);
return (status == GRUB_EFI_SUCCESS); return (status == GRUB_EFI_SUCCESS);
} }
@ -115,5 +115,5 @@ grub_relocator_firmware_free_region (grub_addr_t start, grub_size_t size)
return; return;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_2 (b->free_pages, start, size >> 12); b->free_pages (start, size >> 12);
} }

8
grub-core/loader/efi/appleloader.c
View File

@ -40,7 +40,7 @@ grub_appleloader_unload (void)
grub_efi_boot_services_t *b; grub_efi_boot_services_t *b;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_1 (b->unload_image, image_handle); b->unload_image (image_handle);
grub_free (cmdline); grub_free (cmdline);
cmdline = 0; cmdline = 0;
@ -55,7 +55,7 @@ grub_appleloader_boot (void)
grub_efi_boot_services_t *b; grub_efi_boot_services_t *b;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_3 (b->start_image, image_handle, 0, 0); b->start_image (image_handle, 0, 0);
grub_appleloader_unload (); grub_appleloader_unload ();
@ -165,8 +165,8 @@ grub_cmd_appleloader (grub_command_t cmd __attribute__ ((unused)),
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
for (pdev = devs ; pdev->devpath ; pdev++) for (pdev = devs ; pdev->devpath ; pdev++)
if (efi_call_6 (b->load_image, 0, grub_efi_image_handle, pdev->devpath, if (b->load_image (0, grub_efi_image_handle, pdev->devpath,
NULL, 0, &image_handle) == GRUB_EFI_SUCCESS) NULL, 0, &image_handle) == GRUB_EFI_SUCCESS)
break; break;
if (! pdev->devpath) if (! pdev->devpath)

20
grub-core/loader/efi/chainloader.c
View File

@ -56,7 +56,7 @@ grub_chainloader_unload (void *context)
grub_free (loaded_image->load_options); grub_free (loaded_image->load_options);
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
efi_call_1 (b->unload_image, image_handle); b->unload_image (image_handle);
grub_dl_unref (my_mod); grub_dl_unref (my_mod);
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
@ -72,7 +72,7 @@ grub_chainloader_boot (void *context)
grub_efi_char16_t *exit_data = NULL; grub_efi_char16_t *exit_data = NULL;
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_3 (b->start_image, image_handle, &exit_data_size, &exit_data); status = b->start_image (image_handle, &exit_data_size, &exit_data);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
if (exit_data) if (exit_data)
@ -94,7 +94,7 @@ grub_chainloader_boot (void *context)
} }
if (exit_data) if (exit_data)
efi_call_1 (b->free_pool, exit_data); b->free_pool (exit_data);
grub_loader_unset (); grub_loader_unset ();
@ -289,7 +289,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
} }
pages = (((grub_efi_uintn_t) size + ((1 << 12) - 1)) >> 12); pages = (((grub_efi_uintn_t) size + ((1 << 12) - 1)) >> 12);
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ANY_PAGES, status = b->allocate_pages (GRUB_EFI_ALLOCATE_ANY_PAGES,
GRUB_EFI_LOADER_CODE, GRUB_EFI_LOADER_CODE,
pages, &address); pages, &address);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
@ -346,9 +346,9 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
} }
#endif #endif
status = efi_call_6 (b->load_image, 0, grub_efi_image_handle, file_path, status = b->load_image (0, grub_efi_image_handle, file_path,
boot_image, size, boot_image, size,
&image_handle); &image_handle);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
if (status == GRUB_EFI_OUT_OF_RESOURCES) if (status == GRUB_EFI_OUT_OF_RESOURCES)
@ -403,7 +403,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_device_close (dev); grub_device_close (dev);
/* We're finished with the source image buffer and file path now. */ /* We're finished with the source image buffer and file path now. */
efi_call_2 (b->free_pages, address, pages); b->free_pages (address, pages);
grub_free (file_path); grub_free (file_path);
grub_loader_set_ex (grub_chainloader_boot, grub_chainloader_unload, image_handle, 0); grub_loader_set_ex (grub_chainloader_boot, grub_chainloader_unload, image_handle, 0);
@ -421,10 +421,10 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_free (file_path); grub_free (file_path);
if (address) if (address)
efi_call_2 (b->free_pages, address, pages); b->free_pages (address, pages);
if (image_handle != NULL) if (image_handle != NULL)
efi_call_1 (b->unload_image, image_handle); b->unload_image (image_handle);
grub_dl_unref (my_mod); grub_dl_unref (my_mod);

16
grub-core/mmap/efi/mmap.c
View File

@ -203,14 +203,14 @@ grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
address = start & (~0xfffULL); address = start & (~0xfffULL);
pages = (end - address + 0xfff) >> 12; pages = (end - address + 0xfff) >> 12;
status = efi_call_2 (b->free_pages, address, pages); status = b->free_pages (address, pages);
if (status != GRUB_EFI_SUCCESS && status != GRUB_EFI_NOT_FOUND) if (status != GRUB_EFI_SUCCESS && status != GRUB_EFI_NOT_FOUND)
{ {
grub_free (curover); grub_free (curover);
return 0; return 0;
} }
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ADDRESS, status = b->allocate_pages (GRUB_EFI_ALLOCATE_ADDRESS,
make_efi_memtype (type), pages, &address); make_efi_memtype (type), pages, &address);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
grub_free (curover); grub_free (curover);
@ -239,7 +239,7 @@ grub_mmap_unregister (int handle)
{ {
if (curover->handle == handle) if (curover->handle == handle)
{ {
efi_call_2 (b->free_pages, curover->address, curover->pages); b->free_pages (curover->address, curover->pages);
if (prevover != 0) if (prevover != 0)
prevover->next = curover->next; prevover->next = curover->next;
else else
@ -281,8 +281,8 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
#endif #endif
pages = (size + 0xfff) >> 12; pages = (size + 0xfff) >> 12;
status = efi_call_4 (b->allocate_pages, atype, status = b->allocate_pages (atype,
make_efi_memtype (type), pages, &address); make_efi_memtype (type), pages, &address);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
{ {
grub_free (curover); grub_free (curover);
@ -294,8 +294,8 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
/* Uggh, the address 0 was allocated... This is too annoying, /* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */ so reallocate another one. */
address = 0xffffffff; address = 0xffffffff;
status = efi_call_4 (b->allocate_pages, atype, status = b->allocate_pages (atype,
make_efi_memtype (type), pages, &address); make_efi_memtype (type), pages, &address);
grub_efi_free_pages (0, pages); grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return 0; return 0;

26
grub-core/net/drivers/efi/efinet.c
View File

@ -46,7 +46,7 @@ send_card_buffer (struct grub_net_card *dev,
while (1) while (1)
{ {
txbuf = NULL; txbuf = NULL;
st = efi_call_3 (net->get_status, net, 0, &txbuf); st = net->get_status (net, 0, &txbuf);
if (st != GRUB_EFI_SUCCESS) if (st != GRUB_EFI_SUCCESS)
return grub_error (GRUB_ERR_IO, return grub_error (GRUB_ERR_IO,
N_("couldn't send network packet")); N_("couldn't send network packet"));
@ -74,8 +74,8 @@ send_card_buffer (struct grub_net_card *dev,
grub_memcpy (dev->txbuf, pack->data, dev->last_pkt_size); grub_memcpy (dev->txbuf, pack->data, dev->last_pkt_size);
st = efi_call_7 (net->transmit, net, 0, dev->last_pkt_size, st = net->transmit (net, 0, dev->last_pkt_size,
dev->txbuf, NULL, NULL, NULL); dev->txbuf, NULL, NULL, NULL);
if (st != GRUB_EFI_SUCCESS) if (st != GRUB_EFI_SUCCESS)
return grub_error (GRUB_ERR_IO, N_("couldn't send network packet")); return grub_error (GRUB_ERR_IO, N_("couldn't send network packet"));
@ -88,7 +88,7 @@ send_card_buffer (struct grub_net_card *dev,
Perhaps a timeout in the FW has discarded the recycle buffer. Perhaps a timeout in the FW has discarded the recycle buffer.
*/ */
txbuf = NULL; txbuf = NULL;
st = efi_call_3 (net->get_status, net, 0, &txbuf); st = net->get_status (net, 0, &txbuf);
dev->txbusy = !(st == GRUB_EFI_SUCCESS && txbuf); dev->txbusy = !(st == GRUB_EFI_SUCCESS && txbuf);
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
@ -114,8 +114,8 @@ get_card_packet (struct grub_net_card *dev)
if (!dev->rcvbuf) if (!dev->rcvbuf)
return NULL; return NULL;
st = efi_call_7 (net->receive, net, NULL, &bufsize, st = net->receive (net, NULL, &bufsize,
dev->rcvbuf, NULL, NULL, NULL); dev->rcvbuf, NULL, NULL, NULL);
if (st != GRUB_EFI_BUFFER_TOO_SMALL) if (st != GRUB_EFI_BUFFER_TOO_SMALL)
break; break;
dev->rcvbufsize = 2 * ALIGN_UP (dev->rcvbufsize > bufsize dev->rcvbufsize = 2 * ALIGN_UP (dev->rcvbufsize > bufsize
@ -168,7 +168,7 @@ open_card (struct grub_net_card *dev)
if (net != NULL) if (net != NULL)
{ {
if (net->mode->state == GRUB_EFI_NETWORK_STOPPED if (net->mode->state == GRUB_EFI_NETWORK_STOPPED
&& efi_call_1 (net->start, net) != GRUB_EFI_SUCCESS) && net->start (net) != GRUB_EFI_SUCCESS)
return grub_error (GRUB_ERR_NET_NO_CARD, "%s: net start failed", return grub_error (GRUB_ERR_NET_NO_CARD, "%s: net start failed",
dev->name); dev->name);
@ -177,7 +177,7 @@ open_card (struct grub_net_card *dev)
dev->name); dev->name);
if (net->mode->state == GRUB_EFI_NETWORK_STARTED if (net->mode->state == GRUB_EFI_NETWORK_STARTED
&& efi_call_3 (net->initialize, net, 0, 0) != GRUB_EFI_SUCCESS) && net->initialize (net, 0, 0) != GRUB_EFI_SUCCESS)
return grub_error (GRUB_ERR_NET_NO_CARD, "%s: net initialize failed", return grub_error (GRUB_ERR_NET_NO_CARD, "%s: net initialize failed",
dev->name); dev->name);
@ -201,7 +201,7 @@ open_card (struct grub_net_card *dev)
filters |= (net->mode->receive_filter_mask & filters |= (net->mode->receive_filter_mask &
GRUB_EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS); GRUB_EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS);
efi_call_6 (net->receive_filters, net, filters, 0, 0, 0, NULL); net->receive_filters (net, filters, 0, 0, 0, NULL);
} }
dev->efi_net = net; dev->efi_net = net;
@ -216,8 +216,8 @@ open_card (struct grub_net_card *dev)
static void static void
close_card (struct grub_net_card *dev) close_card (struct grub_net_card *dev)
{ {
efi_call_1 (dev->efi_net->shutdown, dev->efi_net); dev->efi_net->shutdown (dev->efi_net);
efi_call_1 (dev->efi_net->stop, dev->efi_net); dev->efi_net->stop (dev->efi_net);
grub_efi_close_protocol (dev->efi_handle, &net_io_guid); grub_efi_close_protocol (dev->efi_handle, &net_io_guid);
} }
@ -286,14 +286,14 @@ grub_efinet_findcards (void)
continue; continue;
if (net->mode->state == GRUB_EFI_NETWORK_STOPPED if (net->mode->state == GRUB_EFI_NETWORK_STOPPED
&& efi_call_1 (net->start, net) != GRUB_EFI_SUCCESS) && net->start (net) != GRUB_EFI_SUCCESS)
continue; continue;
if (net->mode->state == GRUB_EFI_NETWORK_STOPPED) if (net->mode->state == GRUB_EFI_NETWORK_STOPPED)
continue; continue;
if (net->mode->state == GRUB_EFI_NETWORK_STARTED if (net->mode->state == GRUB_EFI_NETWORK_STARTED
&& efi_call_3 (net->initialize, net, 0, 0) != GRUB_EFI_SUCCESS) && net->initialize (net, 0, 0) != GRUB_EFI_SUCCESS)
continue; continue;
card = grub_zalloc (sizeof (struct grub_net_card)); card = grub_zalloc (sizeof (struct grub_net_card));

29
grub-core/term/efi/console.c
View File

@ -107,14 +107,13 @@ grub_console_setcolorstate (struct grub_term_output *term
switch (state) { switch (state) {
case GRUB_TERM_COLOR_STANDARD: case GRUB_TERM_COLOR_STANDARD:
efi_call_2 (o->set_attributes, o, GRUB_TERM_DEFAULT_STANDARD_COLOR o->set_attributes (o, GRUB_TERM_DEFAULT_STANDARD_COLOR & 0x7f);
& 0x7f);
break; break;
case GRUB_TERM_COLOR_NORMAL: case GRUB_TERM_COLOR_NORMAL:
efi_call_2 (o->set_attributes, o, grub_term_normal_color & 0x7f); o->set_attributes (o, grub_term_normal_color & 0x7f);
break; break;
case GRUB_TERM_COLOR_HIGHLIGHT: case GRUB_TERM_COLOR_HIGHLIGHT:
efi_call_2 (o->set_attributes, o, grub_term_highlight_color & 0x7f); o->set_attributes (o, grub_term_highlight_color & 0x7f);
break; break;
default: default:
break; break;
@ -135,7 +134,7 @@ grub_console_setcursor (struct grub_term_output *term __attribute__ ((unused)),
} }
o = grub_efi_system_table->con_out; o = grub_efi_system_table->con_out;
efi_call_2 (o->enable_cursor, o, on); o->enable_cursor (o, on);
} }
static grub_err_t static grub_err_t
@ -189,10 +188,10 @@ grub_console_putchar (struct grub_term_output *term,
/* Should this test be cached? */ /* Should this test be cached? */
if ((c->base > 0x7f || c->ncomb) if ((c->base > 0x7f || c->ncomb)
&& efi_call_2 (o->test_string, o, str) != GRUB_EFI_SUCCESS) && o->test_string (o, str) != GRUB_EFI_SUCCESS)
return; return;
efi_call_2 (o->output_string, o, str); o->output_string (o, str);
} }
const unsigned efi_codes[] = const unsigned efi_codes[] =
@ -242,7 +241,7 @@ grub_console_getkey_con (struct grub_term_input *term __attribute__ ((unused)))
grub_efi_status_t status; grub_efi_status_t status;
i = grub_efi_system_table->con_in; i = grub_efi_system_table->con_in;
status = efi_call_2 (i->read_key_stroke, i, &key); status = i->read_key_stroke (i, &key);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return GRUB_TERM_NO_KEY; return GRUB_TERM_NO_KEY;
@ -270,7 +269,7 @@ grub_console_read_key_stroke (
key = grub_efi_translate_key (key_data.key); key = grub_efi_translate_key (key_data.key);
if (key == GRUB_TERM_NO_KEY) { if (key == GRUB_TERM_NO_KEY) {
status = efi_call_2 (text_input->read_key_stroke, text_input, &key_data); status = text_input->read_key_stroke (text_input, &key_data);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return GRUB_ERR_EOF; return GRUB_ERR_EOF;
@ -391,8 +390,8 @@ grub_console_getwh (struct grub_term_output *term)
o = grub_efi_system_table->con_out; o = grub_efi_system_table->con_out;
if (grub_prepare_for_text_output (term) != GRUB_ERR_NONE || if (grub_prepare_for_text_output (term) != GRUB_ERR_NONE ||
efi_call_4 (o->query_mode, o, o->mode->mode, o->query_mode (o, o->mode->mode,
&columns, &rows) != GRUB_EFI_SUCCESS) &columns, &rows) != GRUB_EFI_SUCCESS)
{ {
/* Why does this fail? */ /* Why does this fail? */
columns = 80; columns = 80;
@ -424,7 +423,7 @@ grub_console_gotoxy (struct grub_term_output *term,
return; return;
o = grub_efi_system_table->con_out; o = grub_efi_system_table->con_out;
efi_call_3 (o->set_cursor_position, o, pos.x, pos.y); o->set_cursor_position (o, pos.x, pos.y);
} }
static void static void
@ -438,9 +437,9 @@ grub_console_cls (struct grub_term_output *term __attribute__ ((unused)))
o = grub_efi_system_table->con_out; o = grub_efi_system_table->con_out;
orig_attr = o->mode->attribute; orig_attr = o->mode->attribute;
efi_call_2 (o->set_attributes, o, GRUB_EFI_BACKGROUND_BLACK); o->set_attributes (o, GRUB_EFI_BACKGROUND_BLACK);
efi_call_1 (o->clear_screen, o); o->clear_screen (o);
efi_call_2 (o->set_attributes, o, orig_attr); o->set_attributes (o, orig_attr);
} }
static grub_err_t static grub_err_t

18
grub-core/term/efi/serial.c
View File

@ -51,16 +51,16 @@ do_real_config (struct grub_serial_port *port)
if (port->configured) if (port->configured)
return; return;
status = efi_call_7 (port->interface->set_attributes, port->interface, status = port->interface->set_attributes (port->interface,
port->config.speed, port->config.speed,
0, 0, parities[port->config.parity], 0, 0, parities[port->config.parity],
port->config.word_len, port->config.word_len,
stop_bits[port->config.stop_bits]); stop_bits[port->config.stop_bits]);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
port->broken = 1; port->broken = 1;
status = efi_call_2 (port->interface->set_control_bits, port->interface, status = port->interface->set_control_bits (port->interface,
port->config.rtscts ? 0x4002 : 0x2); port->config.rtscts ? 0x4002 : 0x2);
port->configured = 1; port->configured = 1;
} }
@ -76,7 +76,7 @@ serial_hw_fetch (struct grub_serial_port *port)
if (port->broken) if (port->broken)
return -1; return -1;
status = efi_call_3 (port->interface->read, port->interface, &bufsize, &c); status = port->interface->read (port->interface, &bufsize, &c);
if (status != GRUB_EFI_SUCCESS || bufsize == 0) if (status != GRUB_EFI_SUCCESS || bufsize == 0)
return -1; return -1;
@ -95,7 +95,7 @@ serial_hw_put (struct grub_serial_port *port, const int c)
if (port->broken) if (port->broken)
return; return;
efi_call_3 (port->interface->write, port->interface, &bufsize, &c0); port->interface->write (port->interface, &bufsize, &c0);
} }
/* Initialize a serial device. PORT is the port number for a serial device. /* Initialize a serial device. PORT is the port number for a serial device.

18
grub-core/video/efi_gop.c
View File

@ -110,7 +110,7 @@ grub_video_gop_fini (void)
{ {
if (restore_needed) if (restore_needed)
{ {
efi_call_2 (gop->set_mode, gop, old_mode); gop->set_mode (gop, old_mode);
restore_needed = 0; restore_needed = 0;
} }
grub_free (framebuffer.offscreen); grub_free (framebuffer.offscreen);
@ -274,7 +274,7 @@ grub_video_gop_iterate (int (*hook) (const struct grub_video_mode_info *info, vo
struct grub_efi_gop_mode_info *info = NULL; struct grub_efi_gop_mode_info *info = NULL;
struct grub_video_mode_info mode_info; struct grub_video_mode_info mode_info;
status = efi_call_4 (gop->query_mode, gop, mode, &size, &info); status = gop->query_mode (gop, mode, &size, &info);
if (status) if (status)
{ {
@ -400,7 +400,7 @@ grub_video_gop_setup (unsigned int width, unsigned int height,
grub_efi_uintn_t size; grub_efi_uintn_t size;
grub_efi_status_t status; grub_efi_status_t status;
status = efi_call_4 (gop->query_mode, gop, mode, &size, &info); status = gop->query_mode (gop, mode, &size, &info);
if (status) if (status)
{ {
info = 0; info = 0;
@ -461,7 +461,7 @@ grub_video_gop_setup (unsigned int width, unsigned int height,
old_mode = gop->mode->mode; old_mode = gop->mode->mode;
restore_needed = 1; restore_needed = 1;
} }
efi_call_2 (gop->set_mode, gop, best_mode); gop->set_mode (gop, best_mode);
} }
info = gop->mode->info; info = gop->mode->info;
@ -523,10 +523,10 @@ grub_video_gop_swap_buffers (void)
{ {
if (framebuffer.offscreen) if (framebuffer.offscreen)
{ {
efi_call_10 (gop->blt, gop, framebuffer.offscreen, gop->blt (gop, framebuffer.offscreen,
GRUB_EFI_BLT_BUFFER_TO_VIDEO, 0, 0, 0, 0, GRUB_EFI_BLT_BUFFER_TO_VIDEO, 0, 0, 0, 0,
framebuffer.mode_info.width, framebuffer.mode_info.height, framebuffer.mode_info.width, framebuffer.mode_info.height,
framebuffer.mode_info.width * 4); framebuffer.mode_info.width * 4);
} }
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
@ -613,7 +613,7 @@ GRUB_MOD_FINI(efi_gop)
{ {
if (restore_needed) if (restore_needed)
{ {
efi_call_2 (gop->set_mode, gop, old_mode); gop->set_mode (gop, old_mode);
restore_needed = 0; restore_needed = 0;
} }
if (gop) if (gop)

8
grub-core/video/efi_uga.c
View File

@ -186,13 +186,13 @@ check_protocol (void)
grub_uint32_t width, height, depth, rate, pixel; grub_uint32_t width, height, depth, rate, pixel;
int ret; int ret;
if (efi_call_5 (c->get_mode, c, &width, &height, &depth, &rate)) if (c->get_mode (c, &width, &height, &depth, &rate))
return 0; return 0;
grub_efi_set_text_mode (0); grub_efi_set_text_mode (0);
pixel = RGB_MAGIC; pixel = RGB_MAGIC;
efi_call_10 (c->blt, c, (struct grub_efi_uga_pixel *) &pixel, c->blt (c, (struct grub_efi_uga_pixel *) &pixel,
GRUB_EFI_UGA_VIDEO_FILL, 0, 0, 0, 0, 1, height, 0); GRUB_EFI_UGA_VIDEO_FILL, 0, 0, 0, 0, 1, height, 0);
ret = find_framebuf (&uga_fb, &uga_pitch); ret = find_framebuf (&uga_fb, &uga_pitch);
grub_efi_set_text_mode (1); grub_efi_set_text_mode (1);
@ -236,7 +236,7 @@ grub_video_uga_setup (unsigned int width, unsigned int height,
grub_uint32_t d; grub_uint32_t d;
grub_uint32_t r; grub_uint32_t r;
if ((! efi_call_5 (uga->get_mode, uga, &w, &h, &d, &r)) && if ((! uga->get_mode (uga, &w, &h, &d, &r)) &&
((! width) || (width == w)) && ((! width) || (width == w)) &&
((! height) || (height == h)) && ((! height) || (height == h)) &&
((! depth) || (depth == d))) ((! depth) || (depth == d)))