[grub2.git] / include / grub / efiemu / efiemu.h

/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2009  Free Software Foundation, Inc.
 *
 *  GRUB is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  GRUB is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GRUB_EFI_EMU_HEADER
#define GRUB_EFI_EMU_HEADER	1

#include <grub/efi/api.h>
#include <grub/file.h>
#include <grub/memory.h>

#define GRUB_EFIEMU_PAGESIZE 4096

/* EFI api defined in 32-bit and 64-bit version*/
struct grub_efi_system_table32
{
  grub_efi_table_header_t hdr;
  grub_efi_uint32_t firmware_vendor;
  grub_efi_uint32_t firmware_revision;
  grub_efi_uint32_t console_in_handler;
  grub_efi_uint32_t con_in;
  grub_efi_uint32_t console_out_handler;
  grub_efi_uint32_t con_out;
  grub_efi_uint32_t standard_error_handle;
  grub_efi_uint32_t std_err;
  grub_efi_uint32_t runtime_services;
  grub_efi_uint32_t boot_services;
  grub_efi_uint32_t num_table_entries;
  grub_efi_uint32_t configuration_table;
} GRUB_PACKED;
typedef struct grub_efi_system_table32  grub_efi_system_table32_t;

struct grub_efi_system_table64
{
  grub_efi_table_header_t hdr;
  grub_efi_uint64_t firmware_vendor;
  grub_efi_uint32_t firmware_revision;
  grub_efi_uint32_t pad;
  grub_efi_uint64_t console_in_handler;
  grub_efi_uint64_t con_in;
  grub_efi_uint64_t console_out_handler;
  grub_efi_uint64_t con_out;
  grub_efi_uint64_t standard_error_handle;
  grub_efi_uint64_t std_err;
  grub_efi_uint64_t runtime_services;
  grub_efi_uint64_t boot_services;
  grub_efi_uint64_t num_table_entries;
  grub_efi_uint64_t configuration_table;
} GRUB_PACKED;
typedef struct grub_efi_system_table64  grub_efi_system_table64_t;

struct grub_efiemu_runtime_services32
{
  grub_efi_table_header_t hdr;
  grub_efi_uint32_t get_time;
  grub_efi_uint32_t set_time;
  grub_efi_uint32_t get_wakeup_time;
  grub_efi_uint32_t set_wakeup_time;
  grub_efi_uint32_t set_virtual_address_map;
  grub_efi_uint32_t convert_pointer;
  grub_efi_uint32_t get_variable;
  grub_efi_uint32_t get_next_variable_name;
  grub_efi_uint32_t set_variable;
  grub_efi_uint32_t get_next_high_monotonic_count;
  grub_efi_uint32_t reset_system;
} GRUB_PACKED;
typedef struct grub_efiemu_runtime_services32 grub_efiemu_runtime_services32_t;

struct grub_efiemu_runtime_services64
{
  grub_efi_table_header_t hdr;
  grub_efi_uint64_t get_time;
  grub_efi_uint64_t set_time;
  grub_efi_uint64_t get_wakeup_time;
  grub_efi_uint64_t set_wakeup_time;
  grub_efi_uint64_t set_virtual_address_map;
  grub_efi_uint64_t convert_pointer;
  grub_efi_uint64_t get_variable;
  grub_efi_uint64_t get_next_variable_name;
  grub_efi_uint64_t set_variable;
  grub_efi_uint64_t get_next_high_monotonic_count;
  grub_efi_uint64_t reset_system;
} GRUB_PACKED;
typedef struct grub_efiemu_runtime_services64 grub_efiemu_runtime_services64_t;

extern grub_efi_system_table32_t *grub_efiemu_system_table32;
extern grub_efi_system_table64_t *grub_efiemu_system_table64;

/* Convenience macros to access currently loaded efiemu */
#define grub_efiemu_system_table ((grub_efiemu_sizeof_uintn_t () == 8) \
				  ? (void *) grub_efiemu_system_table64 \
				  : (void *) grub_efiemu_system_table32)
#define GRUB_EFIEMU_SIZEOF_OF_UINTN (grub_efiemu_sizeof_uintn_t ())
#define GRUB_EFIEMU_SYSTEM_TABLE(x) ((grub_efiemu_sizeof_uintn_t () == 8) \
				     ? grub_efiemu_system_table64->x \
				     : grub_efiemu_system_table32->x)
#define GRUB_EFIEMU_SYSTEM_TABLE_SET(x,y) ((grub_efiemu_sizeof_uintn_t () == 8)\
					   ? (grub_efiemu_system_table64->x \
					      = (y)) \
					   : (grub_efiemu_system_table32->x \
					      = (y)))
#define GRUB_EFIEMU_SYSTEM_TABLE_PTR(x) ((grub_efiemu_sizeof_uintn_t () == 8)\
					 ? (void *) (grub_addr_t)	\
					 (grub_efiemu_system_table64->x) \
					 : (void *) (grub_addr_t) \
					 (grub_efiemu_system_table32->x))
#define GRUB_EFIEMU_SYSTEM_TABLE_VAR(x) ((grub_efiemu_sizeof_uintn_t () == 8) \
					 ? (void *) \
					 &(grub_efiemu_system_table64->x) \
					 : (void *) \
					 &(grub_efiemu_system_table32->x))
#define GRUB_EFIEMU_SYSTEM_TABLE_SIZEOF(x) \
  ((grub_efiemu_sizeof_uintn_t () == 8) \
   ? sizeof(grub_efiemu_system_table64->x)\
   : sizeof(grub_efiemu_system_table32->x))
#define GRUB_EFIEMU_SYSTEM_TABLE_SIZEOF_TOTAL ((grub_efiemu_sizeof_uintn_t () == 8) ? sizeof(*grub_efiemu_system_table64):sizeof(*grub_efiemu_system_table32))

/* ELF management definitions and functions */

struct grub_efiemu_segment
{
  struct grub_efiemu_segment *next;
  grub_size_t size;
  unsigned section;
  int handle;
  int ptv_rel_needed;
  grub_off_t off;
  void *srcptr;
};
typedef struct grub_efiemu_segment *grub_efiemu_segment_t;

struct grub_efiemu_elf_sym
{
  int handle;
  grub_off_t off;
  unsigned section;
};

int grub_efiemu_check_header32 (void *ehdr, grub_size_t size);
int grub_efiemu_check_header64 (void *ehdr, grub_size_t size);
grub_err_t grub_efiemu_loadcore_init32 (void *core,
					const char *filename,
					grub_size_t core_size,
					grub_efiemu_segment_t *segments);
grub_err_t grub_efiemu_loadcore_init64 (void *core, const char *filename,
					grub_size_t core_size,
					grub_efiemu_segment_t *segments);
grub_err_t grub_efiemu_loadcore_load32 (void *core,
					grub_size_t core_size,
					grub_efiemu_segment_t segments);
grub_err_t grub_efiemu_loadcore_load64 (void *core,
					grub_size_t core_size,
					grub_efiemu_segment_t segments);
grub_err_t grub_efiemu_loadcore_unload32 (void);
grub_err_t grub_efiemu_loadcore_unload64 (void);
grub_err_t grub_efiemu_loadcore_unload(void);
grub_err_t grub_efiemu_loadcore_init (grub_file_t file,
				      const char *filename);
grub_err_t grub_efiemu_loadcore_load (void);

/* Configuration tables manipulation. Definitions and functions */
struct grub_efiemu_configuration_table
{
  struct grub_efiemu_configuration_table *next;
  grub_efi_guid_t guid;
  void * (*get_table) (void *data);
  void (*unload) (void *data);
  void *data;
};
struct grub_efiemu_configuration_table32
{
  grub_efi_packed_guid_t vendor_guid;
  grub_efi_uint32_t vendor_table;
} GRUB_PACKED;
typedef struct grub_efiemu_configuration_table32 grub_efiemu_configuration_table32_t;
struct grub_efiemu_configuration_table64
{
  grub_efi_packed_guid_t vendor_guid;
  grub_efi_uint64_t vendor_table;
} GRUB_PACKED;
typedef struct grub_efiemu_configuration_table64 grub_efiemu_configuration_table64_t;
grub_err_t grub_efiemu_unregister_configuration_table (grub_efi_guid_t guid);
grub_err_t
grub_efiemu_register_configuration_table (grub_efi_guid_t guid,
					  void * (*get_table) (void *data),
					  void (*unload) (void *data),
					  void *data);

/* Memory management functions */
int grub_efiemu_request_memalign (grub_size_t align, grub_size_t size,
				  grub_efi_memory_type_t type);
void *grub_efiemu_mm_obtain_request (int handle);
grub_err_t grub_efiemu_mm_unload (void);
grub_err_t grub_efiemu_mm_do_alloc (void);
grub_err_t grub_efiemu_mm_init (void);
void grub_efiemu_mm_return_request (int handle);
grub_efi_memory_type_t grub_efiemu_mm_get_type (int handle);

/* Drop-in replacements for grub_efi_* and grub_machine_* */
int grub_efiemu_get_memory_map (grub_efi_uintn_t *memory_map_size,
				grub_efi_memory_descriptor_t *memory_map,
				grub_efi_uintn_t *map_key,
				grub_efi_uintn_t *descriptor_size,
				grub_efi_uint32_t *descriptor_version);


grub_err_t
grub_efiemu_finish_boot_services (grub_efi_uintn_t *memory_map_size,
				  grub_efi_memory_descriptor_t *memory_map,
				  grub_efi_uintn_t *map_key,
				  grub_efi_uintn_t *descriptor_size,
				  grub_efi_uint32_t *descriptor_version);

grub_err_t
grub_efiemu_mmap_iterate (grub_memory_hook_t hook, void *hook_data);
int grub_efiemu_sizeof_uintn_t (void);
grub_err_t
grub_efiemu_get_lower_upper_memory (grub_uint64_t *lower, grub_uint64_t *upper);

/* efiemu main control definitions and functions*/
typedef enum {GRUB_EFIEMU_NOTLOADED,
	      GRUB_EFIEMU32, GRUB_EFIEMU64} grub_efiemu_mode_t;
struct grub_efiemu_prepare_hook
{
  struct grub_efiemu_prepare_hook *next;
  grub_err_t (*hook) (void *data);
  void (*unload) (void *data);
  void *data;
};
grub_err_t grub_efiemu_prepare32 (struct grub_efiemu_prepare_hook
				  *prepare_hooks,
				  struct grub_efiemu_configuration_table
				  *config_tables);
grub_err_t grub_efiemu_prepare64 (struct grub_efiemu_prepare_hook
				  *prepare_hooks,
				  struct grub_efiemu_configuration_table
				  *config_tables);
grub_err_t grub_efiemu_unload (void);
grub_err_t grub_efiemu_prepare (void);
grub_err_t
grub_efiemu_register_prepare_hook (grub_err_t (*hook) (void *data),
				   void (*unload) (void *data),
				   void *data);

/* symbols and pointers */
grub_err_t grub_efiemu_alloc_syms (void);
grub_err_t grub_efiemu_request_symbols (int num);
grub_err_t grub_efiemu_resolve_symbol (const char *name,
				       int *handle, grub_off_t *off);
grub_err_t grub_efiemu_register_symbol (const char *name,
					int handle, grub_off_t off);
void grub_efiemu_free_syms (void);
grub_err_t grub_efiemu_write_value (void * addr, grub_uint32_t value,
				    int plus_handle,
				    int minus_handle, int ptv_needed, int size);
grub_err_t grub_efiemu_write_sym_markers (void);
grub_err_t grub_efiemu_pnvram (void);
const char *grub_efiemu_get_default_core_name (void);
void grub_efiemu_pnvram_cmd_unregister (void);
grub_err_t grub_efiemu_autocore (void);
grub_err_t grub_efiemu_crc32 (void);
grub_err_t grub_efiemu_crc64 (void);
grub_err_t
grub_efiemu_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
				     grub_efi_uintn_t descriptor_size,
				     grub_efi_uint32_t descriptor_version
				     __attribute__ ((unused)),
				     grub_efi_memory_descriptor_t *virtual_map);

grub_err_t grub_machine_efiemu_init_tables (void);

#endif /* ! GRUB_EFI_EMU_HEADER */
Commit	Line	Data
5caf964d	1	/*
	2	* GRUB -- GRand Unified Bootloader
	3	* Copyright (C) 2009 Free Software Foundation, Inc.
	4	*
	5	* GRUB is free software: you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation, either version 3 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* GRUB is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#ifndef GRUB_EFI_EMU_HEADER
	20	#define GRUB_EFI_EMU_HEADER 1
	21
	22	#include <grub/efi/api.h>
	23	#include <grub/file.h>
4ed4ce58	24	#include <grub/memory.h>
5caf964d	25
	26	#define GRUB_EFIEMU_PAGESIZE 4096
	27
	28	/* EFI api defined in 32-bit and 64-bit version*/
	29	struct grub_efi_system_table32
	30	{
	31	grub_efi_table_header_t hdr;
	32	grub_efi_uint32_t firmware_vendor;
	33	grub_efi_uint32_t firmware_revision;
	34	grub_efi_uint32_t console_in_handler;
	35	grub_efi_uint32_t con_in;
	36	grub_efi_uint32_t console_out_handler;
	37	grub_efi_uint32_t con_out;
	38	grub_efi_uint32_t standard_error_handle;
	39	grub_efi_uint32_t std_err;
	40	grub_efi_uint32_t runtime_services;
	41	grub_efi_uint32_t boot_services;
	42	grub_efi_uint32_t num_table_entries;
	43	grub_efi_uint32_t configuration_table;
7e47e27b	44	} GRUB_PACKED;
5caf964d	45	typedef struct grub_efi_system_table32 grub_efi_system_table32_t;
	46
	47	struct grub_efi_system_table64
	48	{
	49	grub_efi_table_header_t hdr;
	50	grub_efi_uint64_t firmware_vendor;
	51	grub_efi_uint32_t firmware_revision;
	52	grub_efi_uint32_t pad;
	53	grub_efi_uint64_t console_in_handler;
	54	grub_efi_uint64_t con_in;
	55	grub_efi_uint64_t console_out_handler;
	56	grub_efi_uint64_t con_out;
	57	grub_efi_uint64_t standard_error_handle;
	58	grub_efi_uint64_t std_err;
	59	grub_efi_uint64_t runtime_services;
	60	grub_efi_uint64_t boot_services;
	61	grub_efi_uint64_t num_table_entries;
	62	grub_efi_uint64_t configuration_table;
7e47e27b	63	} GRUB_PACKED;
5caf964d	64	typedef struct grub_efi_system_table64 grub_efi_system_table64_t;
	65
	66	struct grub_efiemu_runtime_services32
	67	{
	68	grub_efi_table_header_t hdr;
	69	grub_efi_uint32_t get_time;
	70	grub_efi_uint32_t set_time;
	71	grub_efi_uint32_t get_wakeup_time;
	72	grub_efi_uint32_t set_wakeup_time;
	73	grub_efi_uint32_t set_virtual_address_map;
	74	grub_efi_uint32_t convert_pointer;
	75	grub_efi_uint32_t get_variable;
	76	grub_efi_uint32_t get_next_variable_name;
	77	grub_efi_uint32_t set_variable;
	78	grub_efi_uint32_t get_next_high_monotonic_count;
	79	grub_efi_uint32_t reset_system;
7e47e27b	80	} GRUB_PACKED;
5caf964d	81	typedef struct grub_efiemu_runtime_services32 grub_efiemu_runtime_services32_t;
	82
	83	struct grub_efiemu_runtime_services64
	84	{
	85	grub_efi_table_header_t hdr;
	86	grub_efi_uint64_t get_time;
	87	grub_efi_uint64_t set_time;
	88	grub_efi_uint64_t get_wakeup_time;
	89	grub_efi_uint64_t set_wakeup_time;
	90	grub_efi_uint64_t set_virtual_address_map;
	91	grub_efi_uint64_t convert_pointer;
	92	grub_efi_uint64_t get_variable;
	93	grub_efi_uint64_t get_next_variable_name;
	94	grub_efi_uint64_t set_variable;
	95	grub_efi_uint64_t get_next_high_monotonic_count;
	96	grub_efi_uint64_t reset_system;
7e47e27b	97	} GRUB_PACKED;
5caf964d	98	typedef struct grub_efiemu_runtime_services64 grub_efiemu_runtime_services64_t;
	99
	100	extern grub_efi_system_table32_t *grub_efiemu_system_table32;
	101	extern grub_efi_system_table64_t *grub_efiemu_system_table64;
	102
4241d2b1	103	/* Convenience macros to access currently loaded efiemu */
5caf964d	104	#define grub_efiemu_system_table ((grub_efiemu_sizeof_uintn_t () == 8) \
	105	? (void *) grub_efiemu_system_table64 \
	106	: (void *) grub_efiemu_system_table32)
	107	#define GRUB_EFIEMU_SIZEOF_OF_UINTN (grub_efiemu_sizeof_uintn_t ())
	108	#define GRUB_EFIEMU_SYSTEM_TABLE(x) ((grub_efiemu_sizeof_uintn_t () == 8) \
	109	? grub_efiemu_system_table64->x \
	110	: grub_efiemu_system_table32->x)
	111	#define GRUB_EFIEMU_SYSTEM_TABLE_SET(x,y) ((grub_efiemu_sizeof_uintn_t () == 8)\
	112	? (grub_efiemu_system_table64->x \
	113	= (y)) \
	114	: (grub_efiemu_system_table32->x \
	115	= (y)))
	116	#define GRUB_EFIEMU_SYSTEM_TABLE_PTR(x) ((grub_efiemu_sizeof_uintn_t () == 8)\
f2b60fbd	117	? (void *) (grub_addr_t) \
5caf964d	118	(grub_efiemu_system_table64->x) \
f2b60fbd	119	: (void *) (grub_addr_t) \
5caf964d	120	(grub_efiemu_system_table32->x))
	121	#define GRUB_EFIEMU_SYSTEM_TABLE_VAR(x) ((grub_efiemu_sizeof_uintn_t () == 8) \
	122	? (void *) \
	123	&(grub_efiemu_system_table64->x) \
	124	: (void *) \
	125	&(grub_efiemu_system_table32->x))
	126	#define GRUB_EFIEMU_SYSTEM_TABLE_SIZEOF(x) \
	127	((grub_efiemu_sizeof_uintn_t () == 8) \
	128	? sizeof(grub_efiemu_system_table64->x)\
	129	: sizeof(grub_efiemu_system_table32->x))
	130	#define GRUB_EFIEMU_SYSTEM_TABLE_SIZEOF_TOTAL ((grub_efiemu_sizeof_uintn_t () == 8) ? sizeof(grub_efiemu_system_table64):sizeof(grub_efiemu_system_table32))
	131
	132	/* ELF management definitions and functions */
	133
	134	struct grub_efiemu_segment
	135	{
	136	struct grub_efiemu_segment *next;
	137	grub_size_t size;
	138	unsigned section;
	139	int handle;
	140	int ptv_rel_needed;
	141	grub_off_t off;
	142	void *srcptr;
	143	};
	144	typedef struct grub_efiemu_segment *grub_efiemu_segment_t;
	145
	146	struct grub_efiemu_elf_sym
	147	{
	148	int handle;
	149	grub_off_t off;
	150	unsigned section;
	151	};
	152
	153	int grub_efiemu_check_header32 (void *ehdr, grub_size_t size);
	154	int grub_efiemu_check_header64 (void *ehdr, grub_size_t size);
0331e102 VS	155	grub_err_t grub_efiemu_loadcore_init32 (void *core,
	156	const char *filename,
	157	grub_size_t core_size,
5caf964d	158	grub_efiemu_segment_t *segments);
0331e102 VS	159	grub_err_t grub_efiemu_loadcore_init64 (void core, const char filename,
0331e102 VS	160	grub_size_t core_size,
5caf964d	161	grub_efiemu_segment_t *segments);
b39f9d20	162	grub_err_t grub_efiemu_loadcore_load32 (void *core,
5caf964d	163	grub_size_t core_size,
5caf964d	164	grub_efiemu_segment_t segments);
b39f9d20	165	grub_err_t grub_efiemu_loadcore_load64 (void *core,
5caf964d	166	grub_size_t core_size,
	167	grub_efiemu_segment_t segments);
	168	grub_err_t grub_efiemu_loadcore_unload32 (void);
	169	grub_err_t grub_efiemu_loadcore_unload64 (void);
	170	grub_err_t grub_efiemu_loadcore_unload(void);
0331e102 VS	171	grub_err_t grub_efiemu_loadcore_init (grub_file_t file,
0331e102 VS	172	const char *filename);
5caf964d	173	grub_err_t grub_efiemu_loadcore_load (void);
	174
	175	/* Configuration tables manipulation. Definitions and functions */
	176	struct grub_efiemu_configuration_table
	177	{
	178	struct grub_efiemu_configuration_table *next;
	179	grub_efi_guid_t guid;
	180	void * (get_table) (void data);
	181	void (unload) (void data);
	182	void *data;
	183	};
	184	struct grub_efiemu_configuration_table32
	185	{
6644d973	186	grub_efi_packed_guid_t vendor_guid;
5caf964d	187	grub_efi_uint32_t vendor_table;
7e47e27b	188	} GRUB_PACKED;
5caf964d	189	typedef struct grub_efiemu_configuration_table32 grub_efiemu_configuration_table32_t;
	190	struct grub_efiemu_configuration_table64
	191	{
6644d973	192	grub_efi_packed_guid_t vendor_guid;
5caf964d	193	grub_efi_uint64_t vendor_table;
7e47e27b	194	} GRUB_PACKED;
a58da8c7	195	typedef struct grub_efiemu_configuration_table64 grub_efiemu_configuration_table64_t;
5caf964d	196	grub_err_t grub_efiemu_unregister_configuration_table (grub_efi_guid_t guid);
b39f9d20	197	grub_err_t
b39f9d20	198	grub_efiemu_register_configuration_table (grub_efi_guid_t guid,
5caf964d	199	void * (get_table) (void data),
b39f9d20	200	void (unload) (void data),
5caf964d	201	void *data);
	202
	203	/* Memory management functions */
b39f9d20	204	int grub_efiemu_request_memalign (grub_size_t align, grub_size_t size,
5caf964d	205	grub_efi_memory_type_t type);
5caf964d	206	void *grub_efiemu_mm_obtain_request (int handle);
5caf964d	207	grub_err_t grub_efiemu_mm_unload (void);
	208	grub_err_t grub_efiemu_mm_do_alloc (void);
	209	grub_err_t grub_efiemu_mm_init (void);
5caf964d	210	void grub_efiemu_mm_return_request (int handle);
	211	grub_efi_memory_type_t grub_efiemu_mm_get_type (int handle);
	212
	213	/* Drop-in replacements for grub_efi_* and grub_machine_* */
	214	int grub_efiemu_get_memory_map (grub_efi_uintn_t *memory_map_size,
	215	grub_efi_memory_descriptor_t *memory_map,
	216	grub_efi_uintn_t *map_key,
	217	grub_efi_uintn_t *descriptor_size,
	218	grub_efi_uint32_t *descriptor_version);
65ce0931 VS	219
	220
	221	grub_err_t
	222	grub_efiemu_finish_boot_services (grub_efi_uintn_t *memory_map_size,
	223	grub_efi_memory_descriptor_t *memory_map,
	224	grub_efi_uintn_t *map_key,
	225	grub_efi_uintn_t *descriptor_size,
	226	grub_efi_uint32_t *descriptor_version);
	227
5caf964d	228	grub_err_t
d0d4b8a0	229	grub_efiemu_mmap_iterate (grub_memory_hook_t hook, void *hook_data);
5caf964d	230	int grub_efiemu_sizeof_uintn_t (void);
5caf964d	231	grub_err_t
5caf964d	232	grub_efiemu_get_lower_upper_memory (grub_uint64_t lower, grub_uint64_t upper);
5caf964d	233
	234	/* efiemu main control definitions and functions*/
	235	typedef enum {GRUB_EFIEMU_NOTLOADED,
	236	GRUB_EFIEMU32, GRUB_EFIEMU64} grub_efiemu_mode_t;
	237	struct grub_efiemu_prepare_hook
	238	{
	239	struct grub_efiemu_prepare_hook *next;
	240	grub_err_t (hook) (void data);
	241	void (unload) (void data);
	242	void *data;
	243	};
b39f9d20	244	grub_err_t grub_efiemu_prepare32 (struct grub_efiemu_prepare_hook
5caf964d	245	*prepare_hooks,
b39f9d20	246	struct grub_efiemu_configuration_table
5caf964d	247	*config_tables);
b39f9d20	248	grub_err_t grub_efiemu_prepare64 (struct grub_efiemu_prepare_hook
5caf964d	249	*prepare_hooks,
b39f9d20	250	struct grub_efiemu_configuration_table
5caf964d	251	*config_tables);
	252	grub_err_t grub_efiemu_unload (void);
	253	grub_err_t grub_efiemu_prepare (void);
	254	grub_err_t
	255	grub_efiemu_register_prepare_hook (grub_err_t (hook) (void data),
b39f9d20	256	void (unload) (void data),
5caf964d	257	void *data);
	258
	259	/* symbols and pointers */
	260	grub_err_t grub_efiemu_alloc_syms (void);
	261	grub_err_t grub_efiemu_request_symbols (int num);
b39f9d20	262	grub_err_t grub_efiemu_resolve_symbol (const char *name,
5caf964d	263	int handle, grub_off_t off);
b39f9d20	264	grub_err_t grub_efiemu_register_symbol (const char *name,
5caf964d	265	int handle, grub_off_t off);
5caf964d	266	void grub_efiemu_free_syms (void);
b39f9d20	267	grub_err_t grub_efiemu_write_value (void * addr, grub_uint32_t value,
5caf964d	268	int plus_handle,
5caf964d	269	int minus_handle, int ptv_needed, int size);
8a10b2c6	270	grub_err_t grub_efiemu_write_sym_markers (void);
5caf964d	271	grub_err_t grub_efiemu_pnvram (void);
bf3a3857	272	const char *grub_efiemu_get_default_core_name (void);
5caf964d	273	void grub_efiemu_pnvram_cmd_unregister (void);
5caf964d	274	grub_err_t grub_efiemu_autocore (void);
8a10b2c6	275	grub_err_t grub_efiemu_crc32 (void);
	276	grub_err_t grub_efiemu_crc64 (void);
	277	grub_err_t
	278	grub_efiemu_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
	279	grub_efi_uintn_t descriptor_size,
	280	grub_efi_uint32_t descriptor_version
	281	__attribute__ ((unused)),
	282	grub_efi_memory_descriptor_t *virtual_map);
	283
05f602fc VS	284	grub_err_t grub_machine_efiemu_init_tables (void);
05f602fc VS	285
5caf964d	286	#endif /* ! GRUB_EFI_EMU_HEADER */