Git Repo - linux.git/blob - include/linux/efi.h

1 /* SPDX-License-Identifier: GPL-2.0 */

2 #ifndef _LINUX_EFI_H

3 #define _LINUX_EFI_H

4

5 /*

6 * Extensible Firmware Interface

7 * Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999

8 *

12 * David Mosberger-Tang <[email protected]>

13 * Stephane Eranian <[email protected]>

14 */

15 #include <linux/init.h>

16 #include <linux/string.h>

17 #include <linux/time.h>

18 #include <linux/types.h>

19 #include <linux/proc_fs.h>

20 #include <linux/rtc.h>

21 #include <linux/ioport.h>

22 #include <linux/pfn.h>

23 #include <linux/pstore.h>

24 #include <linux/range.h>

25 #include <linux/reboot.h>

26 #include <linux/uuid.h>

27

28 #include <asm/page.h>

29

30 struct screen_info;

31

32 #define EFI_SUCCESS 0

33 #define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1)))

34 #define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1)))

35 #define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1)))

36 #define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))

37 #define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1)))

38 #define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1)))

39 #define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1)))

40 #define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))

41 #define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1)))

42 #define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1)))

43 #define EFI_ACCESS_DENIED (15 | (1UL << (BITS_PER_LONG-1)))

44 #define EFI_TIMEOUT (18 | (1UL << (BITS_PER_LONG-1)))

45 #define EFI_ABORTED (21 | (1UL << (BITS_PER_LONG-1)))

46 #define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1)))

47

48 typedef unsigned long efi_status_t;

49 typedef u8 efi_bool_t;

50 typedef u16 efi_char16_t; /* UNICODE character */

51 typedef u64 efi_physical_addr_t;

52 typedef void *efi_handle_t;

53

54 #if defined(CONFIG_X86_64)

55 #define __efiapi __attribute__((ms_abi))

56 #elif defined(CONFIG_X86_32)

57 #define __efiapi __attribute__((regparm(0)))

58 #else

59 #define __efiapi

60 #endif

61

62 /*

63 * The UEFI spec and EDK2 reference implementation both define EFI_GUID as

64 * struct { u32 a; u16; b; u16 c; u8 d[8]; }; and so the implied alignment

65 * is 32 bits not 8 bits like our guid_t. In some cases (i.e., on 32-bit ARM),

66 * this means that firmware services invoked by the kernel may assume that

67 * efi_guid_t* arguments are 32-bit aligned, and use memory accessors that

68 * do not tolerate misalignment. So let's set the minimum alignment to 32 bits.

69 *

70 * Note that the UEFI spec as well as some comments in the EDK2 code base

71 * suggest that EFI_GUID should be 64-bit aligned, but this appears to be

72 * a mistake, given that no code seems to exist that actually enforces that

73 * or relies on it.

74 */

75 typedef guid_t efi_guid_t __aligned(__alignof__(u32));

76

77 #define EFI_GUID(a, b, c, d...) ((efi_guid_t){ { \

78 (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \

79 (b) & 0xff, ((b) >> 8) & 0xff, \

80 (c) & 0xff, ((c) >> 8) & 0xff, d } })

81

82 /*

83 * Generic EFI table header

84 */

85 typedef struct {

86 u64 signature;

87 u32 revision;

88 u32 headersize;

89 u32 crc32;

90 u32 reserved;

91 } efi_table_hdr_t;

92

93 /*

94 * Memory map descriptor:

95 */

96

97 /* Memory types: */

98 #define EFI_RESERVED_TYPE 0

99 #define EFI_LOADER_CODE 1

100 #define EFI_LOADER_DATA 2

101 #define EFI_BOOT_SERVICES_CODE 3

102 #define EFI_BOOT_SERVICES_DATA 4

103 #define EFI_RUNTIME_SERVICES_CODE 5

104 #define EFI_RUNTIME_SERVICES_DATA 6

105 #define EFI_CONVENTIONAL_MEMORY 7

106 #define EFI_UNUSABLE_MEMORY 8

107 #define EFI_ACPI_RECLAIM_MEMORY 9

108 #define EFI_ACPI_MEMORY_NVS 10

109 #define EFI_MEMORY_MAPPED_IO 11

110 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12

111 #define EFI_PAL_CODE 13

112 #define EFI_PERSISTENT_MEMORY 14

113 #define EFI_UNACCEPTED_MEMORY 15

114 #define EFI_MAX_MEMORY_TYPE 16

115

116 /* Attribute values: */

117 #define EFI_MEMORY_UC BIT_ULL(0) /* uncached */

118 #define EFI_MEMORY_WC BIT_ULL(1) /* write-coalescing */

119 #define EFI_MEMORY_WT BIT_ULL(2) /* write-through */

120 #define EFI_MEMORY_WB BIT_ULL(3) /* write-back */

121 #define EFI_MEMORY_UCE BIT_ULL(4) /* uncached, exported */

122 #define EFI_MEMORY_WP BIT_ULL(12) /* write-protect */

123 #define EFI_MEMORY_RP BIT_ULL(13) /* read-protect */

124 #define EFI_MEMORY_XP BIT_ULL(14) /* execute-protect */

125 #define EFI_MEMORY_NV BIT_ULL(15) /* non-volatile */

126 #define EFI_MEMORY_MORE_RELIABLE BIT_ULL(16) /* higher reliability */

127 #define EFI_MEMORY_RO BIT_ULL(17) /* read-only */

128 #define EFI_MEMORY_SP BIT_ULL(18) /* soft reserved */

129 #define EFI_MEMORY_CPU_CRYPTO BIT_ULL(19) /* supports encryption */

130 #define EFI_MEMORY_HOT_PLUGGABLE BIT_ULL(20) /* supports unplugging at runtime */

131 #define EFI_MEMORY_RUNTIME BIT_ULL(63) /* range requires runtime mapping */

132

133 #define EFI_MEMORY_DESCRIPTOR_VERSION 1

134

135 #define EFI_PAGE_SHIFT 12

136 #define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)

137 #define EFI_PAGES_MAX (U64_MAX >> EFI_PAGE_SHIFT)

138

139 typedef struct {

140 u32 type;

141 u32 pad;

142 u64 phys_addr;

143 u64 virt_addr;

144 u64 num_pages;

145 u64 attribute;

146 } efi_memory_desc_t;

147

148 typedef struct {

149 efi_guid_t guid;

150 u32 headersize;

151 u32 flags;

152 u32 imagesize;

153 } efi_capsule_header_t;

154

155 /* EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER */

156 struct efi_manage_capsule_header {

157 u32 ver;

158 u16 emb_drv_cnt;

159 u16 payload_cnt;

160 /*

161 * Variable-size array of the size given by the sum of

162 * emb_drv_cnt and payload_cnt.

163 */

164 u64 offset_list[];

165 } __packed;

166

167 /* EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER */

168 struct efi_manage_capsule_image_header {

169 u32 ver;

170 efi_guid_t image_type_id;

171 u8 image_index;

172 u8 reserved_bytes[3];

173 u32 image_size;

174 u32 vendor_code_size;

175 /* hw_ins was introduced in version 2 */

176 u64 hw_ins;

177 /* capsule_support was introduced in version 3 */

178 u64 capsule_support;

179 } __packed;

180

181 /* WIN_CERTIFICATE */

182 struct win_cert {

183 u32 len;

184 u16 rev;

185 u16 cert_type;

186 };

187

188 /* WIN_CERTIFICATE_UEFI_GUID */

189 struct win_cert_uefi_guid {

190 struct win_cert hdr;

191 efi_guid_t cert_type;

192 u8 cert_data[];

193 };

194

195 /* EFI_FIRMWARE_IMAGE_AUTHENTICATION */

196 struct efi_image_auth {

197 u64 mon_count;

198 struct win_cert_uefi_guid auth_info;

199 };

200

201 /*

202 * EFI capsule flags

203 */

204 #define EFI_CAPSULE_PERSIST_ACROSS_RESET 0x00010000

205 #define EFI_CAPSULE_POPULATE_SYSTEM_TABLE 0x00020000

206 #define EFI_CAPSULE_INITIATE_RESET 0x00040000

207

208 struct capsule_info {

209 efi_capsule_header_t header;

210 efi_capsule_header_t *capsule;

211 int reset_type;

212 long index;

213 size_t count;

214 size_t total_size;

215 struct page **pages;

216 phys_addr_t *phys;

217 size_t page_bytes_remain;

218 };

219

220 int efi_capsule_setup_info(struct capsule_info *cap_info, void *kbuff,

221 size_t hdr_bytes);

222 int __efi_capsule_setup_info(struct capsule_info *cap_info);

223

224 /*

225 * Types and defines for Time Services

226 */

227 #define EFI_TIME_ADJUST_DAYLIGHT 0x1

228 #define EFI_TIME_IN_DAYLIGHT 0x2

229 #define EFI_UNSPECIFIED_TIMEZONE 0x07ff

230

231 typedef struct {

232 u16 year;

233 u8 month;

234 u8 day;

235 u8 hour;

236 u8 minute;

237 u8 second;

238 u8 pad1;

239 u32 nanosecond;

240 s16 timezone;

241 u8 daylight;

242 u8 pad2;

243 } efi_time_t;

244

245 typedef struct {

246 u32 resolution;

247 u32 accuracy;

248 u8 sets_to_zero;

249 } efi_time_cap_t;

250

251 typedef union efi_boot_services efi_boot_services_t;

252

253 /*

254 * Types and defines for EFI ResetSystem

255 */

256 #define EFI_RESET_COLD 0

257 #define EFI_RESET_WARM 1

258 #define EFI_RESET_SHUTDOWN 2

259

260 /*

261 * EFI Runtime Services table

262 */

263 #define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)

264 #define EFI_RUNTIME_SERVICES_REVISION 0x00010000

265

266 typedef struct {

267 efi_table_hdr_t hdr;

268 u32 get_time;

269 u32 set_time;

270 u32 get_wakeup_time;

271 u32 set_wakeup_time;

272 u32 set_virtual_address_map;

273 u32 convert_pointer;

274 u32 get_variable;

275 u32 get_next_variable;

276 u32 set_variable;

277 u32 get_next_high_mono_count;

278 u32 reset_system;

279 u32 update_capsule;

280 u32 query_capsule_caps;

281 u32 query_variable_info;

282 } efi_runtime_services_32_t;

283

284 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);

285 typedef efi_status_t efi_set_time_t (efi_time_t *tm);

286 typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,

287 efi_time_t *tm);

288 typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);

289 typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,

290 unsigned long *data_size, void *data);

291 typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,

292 efi_guid_t *vendor);

293 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor,

294 u32 attr, unsigned long data_size,

295 void *data);

296 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);

297 typedef void efi_reset_system_t (int reset_type, efi_status_t status,

298 unsigned long data_size, efi_char16_t *data);

299 typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,

300 unsigned long descriptor_size,

301 u32 descriptor_version,

302 efi_memory_desc_t *virtual_map);

303 typedef efi_status_t efi_query_variable_info_t(u32 attr,

304 u64 *storage_space,

305 u64 *remaining_space,

306 u64 *max_variable_size);

307 typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,

308 unsigned long count,

309 unsigned long sg_list);

310 typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,

311 unsigned long count,

312 u64 *max_size,

313 int *reset_type);

314 typedef efi_status_t efi_query_variable_store_t(u32 attributes,

315 unsigned long size,

316 bool nonblocking);

317

318 typedef union {

319 struct {

320 efi_table_hdr_t hdr;

321 efi_get_time_t __efiapi *get_time;

322 efi_set_time_t __efiapi *set_time;

323 efi_get_wakeup_time_t __efiapi *get_wakeup_time;

324 efi_set_wakeup_time_t __efiapi *set_wakeup_time;

325 efi_set_virtual_address_map_t __efiapi *set_virtual_address_map;

326 void *convert_pointer;

327 efi_get_variable_t __efiapi *get_variable;

328 efi_get_next_variable_t __efiapi *get_next_variable;

329 efi_set_variable_t __efiapi *set_variable;

330 efi_get_next_high_mono_count_t __efiapi *get_next_high_mono_count;

331 efi_reset_system_t __efiapi *reset_system;

332 efi_update_capsule_t __efiapi *update_capsule;

333 efi_query_capsule_caps_t __efiapi *query_capsule_caps;

334 efi_query_variable_info_t __efiapi *query_variable_info;

335 };

336 efi_runtime_services_32_t mixed_mode;

337 } efi_runtime_services_t;

338

339 void efi_native_runtime_setup(void);

340

341 /*

342 * EFI Configuration Table and GUID definitions

343 *

344 * These are all defined in a single line to make them easier to

345 * grep for and to see them at a glance - while still having a

346 * similar structure to the definitions in the spec.

347 *

348 * Here's how they are structured:

349 *

350 * GUID: 12345678-1234-1234-1234-123456789012

351 * Spec:

352 * #define EFI_SOME_PROTOCOL_GUID \

353 * {0x12345678,0x1234,0x1234,\

354 * {0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x12}}

355 * Here:

356 * #define SOME_PROTOCOL_GUID EFI_GUID(0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12)

357 * ^ tabs ^extra space

358 *

359 * Note that the 'extra space' separates the values at the same place

360 * where the UEFI SPEC breaks the line.

361 */

362 #define NULL_GUID EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)

363 #define ACPI_TABLE_GUID EFI_GUID(0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)

364 #define ACPI_20_TABLE_GUID EFI_GUID(0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81)

365 #define SMBIOS_TABLE_GUID EFI_GUID(0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)

366 #define SMBIOS3_TABLE_GUID EFI_GUID(0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94)

367 #define EFI_GLOBAL_VARIABLE_GUID EFI_GUID(0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c)

368 #define UV_SYSTEM_TABLE_GUID EFI_GUID(0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93)

369 #define LINUX_EFI_CRASH_GUID EFI_GUID(0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0)

370 #define LOADED_IMAGE_PROTOCOL_GUID EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

371 #define LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID EFI_GUID(0xbc62157e, 0x3e33, 0x4fec, 0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf)

372 #define EFI_DEVICE_PATH_PROTOCOL_GUID EFI_GUID(0x09576e91, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

373 #define EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID EFI_GUID(0x8b843e20, 0x8132, 0x4852, 0x90, 0xcc, 0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c)

374 #define EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID EFI_GUID(0x05c99a21, 0xc70f, 0x4ad2, 0x8a, 0x5f, 0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e)

375 #define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID EFI_GUID(0x9042a9de, 0x23dc, 0x4a38, 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a)

376 #define EFI_PCI_IO_PROTOCOL_GUID EFI_GUID(0x4cf5b200, 0x68b8, 0x4ca5, 0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a)

377 #define EFI_FILE_INFO_ID EFI_GUID(0x09576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

378 #define EFI_SYSTEM_RESOURCE_TABLE_GUID EFI_GUID(0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80)

379 #define EFI_FILE_SYSTEM_GUID EFI_GUID(0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

380 #define DEVICE_TREE_GUID EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5, 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0)

381 #define EFI_RNG_PROTOCOL_GUID EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)

382 #define EFI_RNG_ALGORITHM_RAW EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61)

383 #define EFI_MEMORY_ATTRIBUTES_TABLE_GUID EFI_GUID(0xdcfa911d, 0x26eb, 0x469f, 0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20)

384 #define EFI_CONSOLE_OUT_DEVICE_GUID EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)

385 #define APPLE_PROPERTIES_PROTOCOL_GUID EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb, 0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0)

386 #define APPLE_SET_OS_PROTOCOL_GUID EFI_GUID(0xc5c5da95, 0x7d5c, 0x45e6, 0xb2, 0xf1, 0x3f, 0xd5, 0x2b, 0xb1, 0x00, 0x77)

387 #define EFI_TCG2_PROTOCOL_GUID EFI_GUID(0x607f766c, 0x7455, 0x42be, 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)

388 #define EFI_TCG2_FINAL_EVENTS_TABLE_GUID EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)

389 #define EFI_LOAD_FILE_PROTOCOL_GUID EFI_GUID(0x56ec3091, 0x954c, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

390 #define EFI_LOAD_FILE2_PROTOCOL_GUID EFI_GUID(0x4006c0c1, 0xfcb3, 0x403e, 0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d)

391 #define EFI_RT_PROPERTIES_TABLE_GUID EFI_GUID(0xeb66918a, 0x7eef, 0x402a, 0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)

392 #define EFI_DXE_SERVICES_TABLE_GUID EFI_GUID(0x05ad34ba, 0x6f02, 0x4214, 0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9)

393 #define EFI_SMBIOS_PROTOCOL_GUID EFI_GUID(0x03583ff6, 0xcb36, 0x4940, 0x94, 0x7e, 0xb9, 0xb3, 0x9f, 0x4a, 0xfa, 0xf7)

394 #define EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID EFI_GUID(0xf4560cf6, 0x40ec, 0x4b4a, 0xa1, 0x92, 0xbf, 0x1d, 0x57, 0xd0, 0xb1, 0x89)

395

396 #define EFI_IMAGE_SECURITY_DATABASE_GUID EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596, 0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f)

397 #define EFI_SHIM_LOCK_GUID EFI_GUID(0x605dab50, 0xe046, 0x4300, 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)

398

399 #define EFI_CERT_SHA256_GUID EFI_GUID(0xc1c41626, 0x504c, 0x4092, 0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28)

400 #define EFI_CERT_X509_GUID EFI_GUID(0xa5c059a1, 0x94e4, 0x4aa7, 0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72)

401 #define EFI_CERT_X509_SHA256_GUID EFI_GUID(0x3bd2a492, 0x96c0, 0x4079, 0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed)

402 #define EFI_CC_BLOB_GUID EFI_GUID(0x067b1f5f, 0xcf26, 0x44c5, 0x85, 0x54, 0x93, 0xd7, 0x77, 0x91, 0x2d, 0x42)

403 #define EFI_CC_MEASUREMENT_PROTOCOL_GUID EFI_GUID(0x96751a3d, 0x72f4, 0x41a6, 0xa7, 0x94, 0xed, 0x5d, 0x0e, 0x67, 0xae, 0x6b)

404 #define EFI_CC_FINAL_EVENTS_TABLE_GUID EFI_GUID(0xdd4a4648, 0x2de7, 0x4665, 0x96, 0x4d, 0x21, 0xd9, 0xef, 0x5f, 0xb4, 0x46)

405

406 /*

407 * This GUID is used to pass to the kernel proper the struct screen_info

408 * structure that was populated by the stub based on the GOP protocol instance

409 * associated with ConOut

410 */

411 #define LINUX_EFI_SCREEN_INFO_TABLE_GUID EFI_GUID(0xe03fc20a, 0x85dc, 0x406e, 0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95)

412 #define LINUX_EFI_ARM_CPU_STATE_TABLE_GUID EFI_GUID(0xef79e4aa, 0x3c3d, 0x4989, 0xb9, 0x02, 0x07, 0xa9, 0x43, 0xe5, 0x50, 0xd2)

413 #define LINUX_EFI_LOADER_ENTRY_GUID EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf, 0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)

414 #define LINUX_EFI_RANDOM_SEED_TABLE_GUID EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2, 0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)

415 #define LINUX_EFI_TPM_EVENT_LOG_GUID EFI_GUID(0xb7799cb0, 0xeca2, 0x4943, 0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)

416 #define LINUX_EFI_MEMRESERVE_TABLE_GUID EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5, 0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)

417 #define LINUX_EFI_INITRD_MEDIA_GUID EFI_GUID(0x5568e427, 0x68fc, 0x4f3d, 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68)

418 #define LINUX_EFI_MOK_VARIABLE_TABLE_GUID EFI_GUID(0xc451ed2b, 0x9694, 0x45d3, 0xba, 0xba, 0xed, 0x9f, 0x89, 0x88, 0xa3, 0x89)

419 #define LINUX_EFI_COCO_SECRET_AREA_GUID EFI_GUID(0xadf956ad, 0xe98c, 0x484c, 0xae, 0x11, 0xb5, 0x1c, 0x7d, 0x33, 0x64, 0x47)

420 #define LINUX_EFI_BOOT_MEMMAP_GUID EFI_GUID(0x800f683f, 0xd08b, 0x423a, 0xa2, 0x93, 0x96, 0x5c, 0x3c, 0x6f, 0xe2, 0xb4)

421 #define LINUX_EFI_UNACCEPTED_MEM_TABLE_GUID EFI_GUID(0xd5d1de3c, 0x105c, 0x44f9, 0x9e, 0xa9, 0xbc, 0xef, 0x98, 0x12, 0x00, 0x31)

422

423 #define RISCV_EFI_BOOT_PROTOCOL_GUID EFI_GUID(0xccd15fec, 0x6f73, 0x4eec, 0x83, 0x95, 0x3e, 0x69, 0xe4, 0xb9, 0x40, 0xbf)

424

425 /*

426 * This GUID may be installed onto the kernel image's handle as a NULL protocol

427 * to signal to the stub that the placement of the image should be respected,

428 * and moving the image in physical memory is undesirable. To ensure

429 * compatibility with 64k pages kernels with virtually mapped stacks, and to

430 * avoid defeating physical randomization, this protocol should only be

431 * installed if the image was placed at a randomized 128k aligned address in

432 * memory.

433 */

434 #define LINUX_EFI_LOADED_IMAGE_FIXED_GUID EFI_GUID(0xf5a37b6d, 0x3344, 0x42a5, 0xb6, 0xbb, 0x97, 0x86, 0x48, 0xc1, 0x89, 0x0a)

435

436 /* OEM GUIDs */

437 #define DELLEMC_EFI_RCI2_TABLE_GUID EFI_GUID(0x2d9f28a2, 0xa886, 0x456a, 0x97, 0xa8, 0xf1, 0x1e, 0xf2, 0x4f, 0xf4, 0x55)

438 #define AMD_SEV_MEM_ENCRYPT_GUID EFI_GUID(0x0cf29b71, 0x9e51, 0x433a, 0xa3, 0xb7, 0x81, 0xf3, 0xab, 0x16, 0xb8, 0x75)

439

440 /* OVMF protocol GUIDs */

441 #define OVMF_SEV_MEMORY_ACCEPTANCE_PROTOCOL_GUID EFI_GUID(0xc5a010fe, 0x38a7, 0x4531, 0x8a, 0x4a, 0x05, 0x00, 0xd2, 0xfd, 0x16, 0x49)

442

443 typedef struct {

444 efi_guid_t guid;

445 u64 table;

446 } efi_config_table_64_t;

447

448 typedef struct {

449 efi_guid_t guid;

450 u32 table;

451 } efi_config_table_32_t;

452

453 typedef union {

454 struct {

455 efi_guid_t guid;

456 void *table;

457 };

458 efi_config_table_32_t mixed_mode;

459 } efi_config_table_t;

460

461 typedef struct {

462 efi_guid_t guid;

463 unsigned long *ptr;

464 const char name[16];

465 } efi_config_table_type_t;

466

467 #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)

468 #define EFI_DXE_SERVICES_TABLE_SIGNATURE ((u64)0x565245535f455844ULL)

469

470 #define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30))

471 #define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20))

472 #define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10))

473 #define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00))

474 #define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10))

475 #define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02))

476

477 typedef struct {

478 efi_table_hdr_t hdr;

479 u64 fw_vendor; /* physical addr of CHAR16 vendor string */

480 u32 fw_revision;

481 u32 __pad1;

482 u64 con_in_handle;

483 u64 con_in;

484 u64 con_out_handle;

485 u64 con_out;

486 u64 stderr_handle;

487 u64 stderr;

488 u64 runtime;

489 u64 boottime;

490 u32 nr_tables;

491 u32 __pad2;

492 u64 tables;

493 } efi_system_table_64_t;

494

495 typedef struct {

496 efi_table_hdr_t hdr;

497 u32 fw_vendor; /* physical addr of CHAR16 vendor string */

498 u32 fw_revision;

499 u32 con_in_handle;

500 u32 con_in;

501 u32 con_out_handle;

502 u32 con_out;

503 u32 stderr_handle;

504 u32 stderr;

505 u32 runtime;

506 u32 boottime;

507 u32 nr_tables;

508 u32 tables;

509 } efi_system_table_32_t;

510

511 typedef union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;

512 typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;

513

514 typedef union {

515 struct {

516 efi_table_hdr_t hdr;

517 unsigned long fw_vendor; /* physical addr of CHAR16 vendor string */

518 u32 fw_revision;

519 unsigned long con_in_handle;

520 efi_simple_text_input_protocol_t *con_in;

521 unsigned long con_out_handle;

522 efi_simple_text_output_protocol_t *con_out;

523 unsigned long stderr_handle;

524 unsigned long stderr;

525 efi_runtime_services_t *runtime;

526 efi_boot_services_t *boottime;

527 unsigned long nr_tables;

528 unsigned long tables;

529 };

530 efi_system_table_32_t mixed_mode;

531 } efi_system_table_t;

532

533 struct efi_boot_memmap {

534 unsigned long map_size;

535 unsigned long desc_size;

536 u32 desc_ver;

537 unsigned long map_key;

538 unsigned long buff_size;

539 efi_memory_desc_t map[];

540 };

541

542 struct efi_unaccepted_memory {

543 u32 version;

544 u32 unit_size;

545 u64 phys_base;

546 u64 size;

547 unsigned long bitmap[];

548 };

549

550 /*

551 * Architecture independent structure for describing a memory map for the

552 * benefit of efi_memmap_init_early(), and for passing context between

553 * efi_memmap_alloc() and efi_memmap_install().

554 */

555 struct efi_memory_map_data {

556 phys_addr_t phys_map;

557 unsigned long size;

558 unsigned long desc_version;

559 unsigned long desc_size;

560 unsigned long flags;

561 };

562

563 struct efi_memory_map {

564 phys_addr_t phys_map;

565 void *map;

566 void *map_end;

567 int nr_map;

568 unsigned long desc_version;

569 unsigned long desc_size;

570 #define EFI_MEMMAP_LATE (1UL << 0)

571 #define EFI_MEMMAP_MEMBLOCK (1UL << 1)

572 #define EFI_MEMMAP_SLAB (1UL << 2)

573 unsigned long flags;

574 };

575

576 struct efi_mem_range {

577 struct range range;

578 u64 attribute;

579 };

580

581 typedef struct {

582 u16 version;

583 u16 length;

584 u32 runtime_services_supported;

585 } efi_rt_properties_table_t;

586

587 #define EFI_RT_PROPERTIES_TABLE_VERSION 0x1

588

589 #define EFI_INVALID_TABLE_ADDR (~0UL)

590

591 // BIT0 implies that Runtime code includes the forward control flow guard

592 // instruction, such as X86 CET-IBT or ARM BTI.

593 #define EFI_MEMORY_ATTRIBUTES_FLAGS_RT_FORWARD_CONTROL_FLOW_GUARD 0x1

594

595 typedef struct {

596 u32 version;

597 u32 num_entries;

598 u32 desc_size;

599 u32 flags;

600 /*

601 * There are @num_entries following, each of size @desc_size bytes,

602 * including an efi_memory_desc_t header. See efi_memdesc_ptr().

603 */

604 efi_memory_desc_t entry[];

605 } efi_memory_attributes_table_t;

606

607 typedef struct {

608 efi_guid_t signature_owner;

609 u8 signature_data[];

610 } efi_signature_data_t;

611

612 typedef struct {

613 efi_guid_t signature_type;

614 u32 signature_list_size;

615 u32 signature_header_size;

616 u32 signature_size;

617 u8 signature_header[];

618 /* efi_signature_data_t signatures[][] */

619 } efi_signature_list_t;

620

621 typedef u8 efi_sha256_hash_t[32];

622

623 typedef struct {

624 efi_sha256_hash_t to_be_signed_hash;

625 efi_time_t time_of_revocation;

626 } efi_cert_x509_sha256_t;

627

628 extern unsigned long __ro_after_init efi_rng_seed; /* RNG Seed table */

629

630 /*

631 * All runtime access to EFI goes through this structure:

632 */

633 extern struct efi {

634 const efi_runtime_services_t *runtime; /* EFI runtime services table */

635 unsigned int runtime_version; /* Runtime services version */

636 unsigned int runtime_supported_mask;

637

638 unsigned long acpi; /* ACPI table (IA64 ext 0.71) */

639 unsigned long acpi20; /* ACPI table (ACPI 2.0) */

640 unsigned long smbios; /* SMBIOS table (32 bit entry point) */

641 unsigned long smbios3; /* SMBIOS table (64 bit entry point) */

642 unsigned long esrt; /* ESRT table */

643 unsigned long tpm_log; /* TPM2 Event Log table */

644 unsigned long tpm_final_log; /* TPM2 Final Events Log table */

645 unsigned long mokvar_table; /* MOK variable config table */

646 unsigned long coco_secret; /* Confidential computing secret table */

647 unsigned long unaccepted; /* Unaccepted memory table */

648

649 efi_get_time_t *get_time;

650 efi_set_time_t *set_time;

651 efi_get_wakeup_time_t *get_wakeup_time;

652 efi_set_wakeup_time_t *set_wakeup_time;

653 efi_get_variable_t *get_variable;

654 efi_get_next_variable_t *get_next_variable;

655 efi_set_variable_t *set_variable;

656 efi_set_variable_t *set_variable_nonblocking;

657 efi_query_variable_info_t *query_variable_info;

658 efi_query_variable_info_t *query_variable_info_nonblocking;

659 efi_update_capsule_t *update_capsule;

660 efi_query_capsule_caps_t *query_capsule_caps;

661 efi_get_next_high_mono_count_t *get_next_high_mono_count;

662 efi_reset_system_t *reset_system;

663

664 struct efi_memory_map memmap;

665 unsigned long flags;

666 } efi;

667

668 #define EFI_RT_SUPPORTED_GET_TIME 0x0001

669 #define EFI_RT_SUPPORTED_SET_TIME 0x0002

670 #define EFI_RT_SUPPORTED_GET_WAKEUP_TIME 0x0004

671 #define EFI_RT_SUPPORTED_SET_WAKEUP_TIME 0x0008

672 #define EFI_RT_SUPPORTED_GET_VARIABLE 0x0010

673 #define EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME 0x0020

674 #define EFI_RT_SUPPORTED_SET_VARIABLE 0x0040

675 #define EFI_RT_SUPPORTED_SET_VIRTUAL_ADDRESS_MAP 0x0080

676 #define EFI_RT_SUPPORTED_CONVERT_POINTER 0x0100

677 #define EFI_RT_SUPPORTED_GET_NEXT_HIGH_MONOTONIC_COUNT 0x0200

678 #define EFI_RT_SUPPORTED_RESET_SYSTEM 0x0400

679 #define EFI_RT_SUPPORTED_UPDATE_CAPSULE 0x0800

680 #define EFI_RT_SUPPORTED_QUERY_CAPSULE_CAPABILITIES 0x1000

681 #define EFI_RT_SUPPORTED_QUERY_VARIABLE_INFO 0x2000

682

683 #define EFI_RT_SUPPORTED_ALL 0x3fff

684

685 #define EFI_RT_SUPPORTED_TIME_SERVICES 0x0003

686 #define EFI_RT_SUPPORTED_WAKEUP_SERVICES 0x000c

687 #define EFI_RT_SUPPORTED_VARIABLE_SERVICES 0x0070

688

689 extern struct mm_struct efi_mm;

690

691 static inline bool mm_is_efi(struct mm_struct *mm)

692 {

693 return IS_ENABLED(CONFIG_EFI) && mm == &efi_mm;

694 }

695

696 static inline int

697 efi_guidcmp (efi_guid_t left, efi_guid_t right)

698 {

699 return memcmp(&left, &right, sizeof (efi_guid_t));

700 }

701

702 static inline char *

703 efi_guid_to_str(efi_guid_t *guid, char *out)

704 {

705 sprintf(out, "%pUl", guid->b);

706 return out;

707 }

708

709 extern void efi_init (void);

710 extern void efi_earlycon_reprobe(void);

711 #ifdef CONFIG_EFI

712 extern void efi_enter_virtual_mode (void); /* switch EFI to virtual mode, if possible */

713 #else

714 static inline void efi_enter_virtual_mode (void) {}

715 #endif

716 #ifdef CONFIG_X86

717 extern efi_status_t efi_query_variable_store(u32 attributes,

718 unsigned long size,

719 bool nonblocking);

720 #else

721

722 static inline efi_status_t efi_query_variable_store(u32 attributes,

723 unsigned long size,

724 bool nonblocking)

725 {

726 return EFI_SUCCESS;

727 }

728 #endif

729

730 extern int __init __efi_memmap_init(struct efi_memory_map_data *data);

731 extern int __init efi_memmap_init_early(struct efi_memory_map_data *data);

732 extern int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size);

733 extern void __init efi_memmap_unmap(void);

734

735 #ifdef CONFIG_EFI_ESRT

736 extern void __init efi_esrt_init(void);

737 #else

738 static inline void efi_esrt_init(void) { }

739 #endif

740 extern int efi_config_parse_tables(const efi_config_table_t *config_tables,

741 int count,

742 const efi_config_table_type_t *arch_tables);

743 extern int efi_systab_check_header(const efi_table_hdr_t *systab_hdr);

744 extern void efi_systab_report_header(const efi_table_hdr_t *systab_hdr,

745 unsigned long fw_vendor);

746 extern u64 efi_get_iobase (void);

747 extern int efi_mem_type(unsigned long phys_addr);

748 extern u64 efi_mem_attributes (unsigned long phys_addr);

749 extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);

750 extern int __init efi_uart_console_only (void);

751 extern u64 efi_mem_desc_end(efi_memory_desc_t *md);

752 extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);

753 extern int __efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);

754 extern void efi_mem_reserve(phys_addr_t addr, u64 size);

755 extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);

756 extern u64 efi_get_fdt_params(struct efi_memory_map_data *data);

757 extern struct kobject *efi_kobj;

758

759 extern int efi_reboot_quirk_mode;

760 extern bool efi_poweroff_required(void);

761

762 extern unsigned long efi_mem_attr_table;

763

764 /*

765 * efi_memattr_perm_setter - arch specific callback function passed into

766 * efi_memattr_apply_permissions() that updates the

767 * mapping permissions described by the second

768 * argument in the page tables referred to by the

769 * first argument.

770 */

771 typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *, bool);

772

773 extern int efi_memattr_init(void);

774 extern int efi_memattr_apply_permissions(struct mm_struct *mm,

775 efi_memattr_perm_setter fn);

776

777 /*

778 * efi_memdesc_ptr - get the n-th EFI memmap descriptor

779 * @map: the start of efi memmap

780 * @desc_size: the size of space for each EFI memmap descriptor

781 * @n: the index of efi memmap descriptor

782 *

783 * EFI boot service provides the GetMemoryMap() function to get a copy of the

784 * current memory map which is an array of memory descriptors, each of

785 * which describes a contiguous block of memory. It also gets the size of the

786 * map, and the size of each descriptor, etc.

787 *

788 * Note that per section 6.2 of UEFI Spec 2.6 Errata A, the returned size of

789 * each descriptor might not be equal to sizeof(efi_memory_memdesc_t),

790 * since efi_memory_memdesc_t may be extended in the future. Thus the OS

791 * MUST use the returned size of the descriptor to find the start of each

792 * efi_memory_memdesc_t in the memory map array. This should only be used

793 * during bootup since for_each_efi_memory_desc_xxx() is available after the

794 * kernel initializes the EFI subsystem to set up struct efi_memory_map.

795 */

796 #define efi_memdesc_ptr(map, desc_size, n) \

797 (efi_memory_desc_t *)((void *)(map) + ((n) * (desc_size)))

798

799 /* Iterate through an efi_memory_map */

800 #define for_each_efi_memory_desc_in_map(m, md) \

801 for ((md) = (m)->map; \

802 (md) && ((void *)(md) + (m)->desc_size) <= (m)->map_end; \

803 (md) = (void *)(md) + (m)->desc_size)

804

805 /**

806 * for_each_efi_memory_desc - iterate over descriptors in efi.memmap

807 * @md: the efi_memory_desc_t * iterator

808 *

809 * Once the loop finishes @md must not be accessed.

810 */

811 #define for_each_efi_memory_desc(md) \

812 for_each_efi_memory_desc_in_map(&efi.memmap, md)

813

814 /*

815 * Format an EFI memory descriptor's type and attributes to a user-provided

816 * character buffer, as per snprintf(), and return the buffer.

817 */

818 char * __init efi_md_typeattr_format(char *buf, size_t size,

819 const efi_memory_desc_t *md);

820

821

822 typedef void (*efi_element_handler_t)(const char *source,

823 const void *element_data,

824 size_t element_size);

825 extern int __init parse_efi_signature_list(

826 const char *source,

827 const void *data, size_t size,

828 efi_element_handler_t (*get_handler_for_guid)(const efi_guid_t *));

829

830 /**

831 * efi_range_is_wc - check the WC bit on an address range

832 * @start: starting kvirt address

833 * @len: length of range

834 *

835 * Consult the EFI memory map and make sure it's ok to set this range WC.

836 * Returns true or false.

837 */

838 static inline int efi_range_is_wc(unsigned long start, unsigned long len)

839 {

840 unsigned long i;

841

842 for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {

843 unsigned long paddr = __pa(start + i);

844 if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))

845 return 0;

846 }

847 /* The range checked out */

848 return 1;

849 }

850

851 /*

852 * We play games with efi_enabled so that the compiler will, if

853 * possible, remove EFI-related code altogether.

854 */

855 #define EFI_BOOT 0 /* Were we booted from EFI? */

856 #define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */

857 #define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */

858 #define EFI_MEMMAP 4 /* Can we use EFI memory map? */

859 #define EFI_64BIT 5 /* Is the firmware 64-bit? */

860 #define EFI_PARAVIRT 6 /* Access is via a paravirt interface */

861 #define EFI_ARCH_1 7 /* First arch-specific bit */

862 #define EFI_DBG 8 /* Print additional debug info at runtime */

863 #define EFI_MEM_ATTR 9 /* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */

864 #define EFI_MEM_NO_SOFT_RESERVE 10 /* Is the kernel configured to ignore soft reservations? */

865 #define EFI_PRESERVE_BS_REGIONS 11 /* Are EFI boot-services memory segments available? */

866

867 #ifdef CONFIG_EFI

868 /*

869 * Test whether the above EFI_* bits are enabled.

870 */

871 static inline bool efi_enabled(int feature)

872 {

873 return test_bit(feature, &efi.flags) != 0;

874 }

875 extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);

876

877 bool __pure __efi_soft_reserve_enabled(void);

878

879 static inline bool __pure efi_soft_reserve_enabled(void)

880 {

881 return IS_ENABLED(CONFIG_EFI_SOFT_RESERVE)

882 && __efi_soft_reserve_enabled();

883 }

884

885 static inline bool efi_rt_services_supported(unsigned int mask)

886 {

887 return (efi.runtime_supported_mask & mask) == mask;

888 }

889 extern void efi_find_mirror(void);

890 #else

891 static inline bool efi_enabled(int feature)

892 {

893 return false;

894 }

895 static inline void

896 efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {}

897

898 static inline bool efi_soft_reserve_enabled(void)

899 {

900 return false;

901 }

902

903 static inline bool efi_rt_services_supported(unsigned int mask)

904 {

905 return false;

906 }

907

908 static inline void efi_find_mirror(void) {}

909 #endif

910

911 extern int efi_status_to_err(efi_status_t status);

912

913 /*

914 * Variable Attributes

915 */

916 #define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001

917 #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002

918 #define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004

919 #define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008

920 #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010

921 #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020

922 #define EFI_VARIABLE_APPEND_WRITE 0x0000000000000040

923

924 #define EFI_VARIABLE_MASK (EFI_VARIABLE_NON_VOLATILE | \

925 EFI_VARIABLE_BOOTSERVICE_ACCESS | \

926 EFI_VARIABLE_RUNTIME_ACCESS | \

927 EFI_VARIABLE_HARDWARE_ERROR_RECORD | \

928 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \

929 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \

930 EFI_VARIABLE_APPEND_WRITE)

931 /*

932 * Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))

933 * not including trailing NUL

934 */

935 #define EFI_VARIABLE_GUID_LEN UUID_STRING_LEN

936

937 /*

938 * EFI Device Path information

939 */

940 #define EFI_DEV_HW 0x01

941 #define EFI_DEV_PCI 1

942 #define EFI_DEV_PCCARD 2

943 #define EFI_DEV_MEM_MAPPED 3

944 #define EFI_DEV_VENDOR 4

945 #define EFI_DEV_CONTROLLER 5

946 #define EFI_DEV_ACPI 0x02

947 #define EFI_DEV_BASIC_ACPI 1

948 #define EFI_DEV_EXPANDED_ACPI 2

949 #define EFI_DEV_MSG 0x03

950 #define EFI_DEV_MSG_ATAPI 1

951 #define EFI_DEV_MSG_SCSI 2

952 #define EFI_DEV_MSG_FC 3

953 #define EFI_DEV_MSG_1394 4

954 #define EFI_DEV_MSG_USB 5

955 #define EFI_DEV_MSG_USB_CLASS 15

956 #define EFI_DEV_MSG_I20 6

957 #define EFI_DEV_MSG_MAC 11

958 #define EFI_DEV_MSG_IPV4 12

959 #define EFI_DEV_MSG_IPV6 13

960 #define EFI_DEV_MSG_INFINIBAND 9

961 #define EFI_DEV_MSG_UART 14

962 #define EFI_DEV_MSG_VENDOR 10

963 #define EFI_DEV_MEDIA 0x04

964 #define EFI_DEV_MEDIA_HARD_DRIVE 1

965 #define EFI_DEV_MEDIA_CDROM 2

966 #define EFI_DEV_MEDIA_VENDOR 3

967 #define EFI_DEV_MEDIA_FILE 4

968 #define EFI_DEV_MEDIA_PROTOCOL 5

969 #define EFI_DEV_MEDIA_REL_OFFSET 8

970 #define EFI_DEV_BIOS_BOOT 0x05

971 #define EFI_DEV_END_PATH 0x7F

972 #define EFI_DEV_END_PATH2 0xFF

973 #define EFI_DEV_END_INSTANCE 0x01

974 #define EFI_DEV_END_ENTIRE 0xFF

975

976 struct efi_generic_dev_path {

977 u8 type;

978 u8 sub_type;

979 u16 length;

980 } __packed;

981

982 struct efi_acpi_dev_path {

983 struct efi_generic_dev_path header;

984 u32 hid;

985 u32 uid;

986 } __packed;

987

988 struct efi_pci_dev_path {

989 struct efi_generic_dev_path header;

990 u8 fn;

991 u8 dev;

992 } __packed;

993

994 struct efi_vendor_dev_path {

995 struct efi_generic_dev_path header;

996 efi_guid_t vendorguid;

997 u8 vendordata[];

998 } __packed;

999

1000 struct efi_rel_offset_dev_path {

1001 struct efi_generic_dev_path header;

1002 u32 reserved;

1003 u64 starting_offset;

1004 u64 ending_offset;

1005 } __packed;

1006

1007 struct efi_mem_mapped_dev_path {

1008 struct efi_generic_dev_path header;

1009 u32 memory_type;

1010 u64 starting_addr;

1011 u64 ending_addr;

1012 } __packed;

1013

1014 struct efi_file_path_dev_path {

1015 struct efi_generic_dev_path header;

1016 efi_char16_t filename[];

1017 } __packed;

1018

1019 struct efi_dev_path {

1020 union {

1021 struct efi_generic_dev_path header;

1022 struct efi_acpi_dev_path acpi;

1023 struct efi_pci_dev_path pci;

1024 struct efi_vendor_dev_path vendor;

1025 struct efi_rel_offset_dev_path rel_offset;

1026 };

1027 } __packed;

1028

1029 struct device *efi_get_device_by_path(const struct efi_dev_path **node,

1030 size_t *len);

1031

1032 static inline void memrange_efi_to_native(u64 *addr, u64 *npages)

1033 {

1034 *npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr);

1035 *addr &= PAGE_MASK;

1036 }

1037

1038 /*

1039 * EFI Variable support.

1040 *

1041 * Different firmware drivers can expose their EFI-like variables using

1042 * the following.

1043 */

1044

1045 struct efivar_operations {

1046 efi_get_variable_t *get_variable;

1047 efi_get_next_variable_t *get_next_variable;

1048 efi_set_variable_t *set_variable;

1049 efi_set_variable_t *set_variable_nonblocking;

1050 efi_query_variable_store_t *query_variable_store;

1051 efi_query_variable_info_t *query_variable_info;

1052 };

1053

1054 struct efivars {

1055 struct kset *kset;

1056 const struct efivar_operations *ops;

1057 };

1058

1059 #ifdef CONFIG_X86

1060 u64 __attribute_const__ efivar_reserved_space(void);

1061 #else

1062 static inline u64 efivar_reserved_space(void) { return 0; }

1063 #endif

1064

1065 /*

1066 * There is no actual upper limit specified for the variable name size.

1067 *

1068 * This limit exists only for practical purposes, since name conversions

1069 * are bounds-checked and name data is occasionally stored in-line.

1070 */

1071 #define EFI_VAR_NAME_LEN 1024

1072

1073 int efivars_register(struct efivars *efivars,

1074 const struct efivar_operations *ops);

1075 int efivars_unregister(struct efivars *efivars);

1076

1077 #ifdef CONFIG_EFI

1078 bool efivar_is_available(void);

1079 #else

1080 static inline bool efivar_is_available(void) { return false; }

1081 #endif

1082

1083 bool efivar_supports_writes(void);

1084

1085 int efivar_lock(void);

1086 int efivar_trylock(void);

1087 void efivar_unlock(void);

1088

1089 efi_status_t efivar_get_variable(efi_char16_t *name, efi_guid_t *vendor,

1090 u32 *attr, unsigned long *size, void *data);

1091

1092 efi_status_t efivar_get_next_variable(unsigned long *name_size,

1093 efi_char16_t *name, efi_guid_t *vendor);

1094

1095 efi_status_t efivar_set_variable_locked(efi_char16_t *name, efi_guid_t *vendor,

1096 u32 attr, unsigned long data_size,

1097 void *data, bool nonblocking);

1098

1099 efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor,

1100 u32 attr, unsigned long data_size, void *data);

1101

1102 efi_status_t efivar_query_variable_info(u32 attr, u64 *storage_space,

1103 u64 *remaining_space,

1104 u64 *max_variable_size);

1105

1106 #if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER)

1107 extern bool efi_capsule_pending(int *reset_type);

1108

1109 extern int efi_capsule_supported(efi_guid_t guid, u32 flags,

1110 size_t size, int *reset);

1111

1112 extern int efi_capsule_update(efi_capsule_header_t *capsule,

1113 phys_addr_t *pages);

1114 #else

1115 static inline bool efi_capsule_pending(int *reset_type) { return false; }

1116 #endif

1117

1118 #ifdef CONFIG_EFI

1119 extern bool efi_runtime_disabled(void);

1120 #else

1121 static inline bool efi_runtime_disabled(void) { return true; }

1122 #endif

1123

1124 extern void efi_call_virt_check_flags(unsigned long flags, const void *caller);

1125 extern unsigned long efi_call_virt_save_flags(void);

1126

1127 enum efi_secureboot_mode {

1128 efi_secureboot_mode_unset,

1129 efi_secureboot_mode_unknown,

1130 efi_secureboot_mode_disabled,

1131 efi_secureboot_mode_enabled,

1132 };

1133

1134 static inline

1135 enum efi_secureboot_mode efi_get_secureboot_mode(efi_get_variable_t *get_var)

1136 {

1137 u8 secboot, setupmode = 0;

1138 efi_status_t status;

1139 unsigned long size;

1140

1141 size = sizeof(secboot);

1142 status = get_var(L"SecureBoot", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size,

1143 &secboot);

1144 if (status == EFI_NOT_FOUND)

1145 return efi_secureboot_mode_disabled;

1146 if (status != EFI_SUCCESS)

1147 return efi_secureboot_mode_unknown;

1148

1149 size = sizeof(setupmode);

1150 get_var(L"SetupMode", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size, &setupmode);

1151 if (secboot == 0 || setupmode == 1)

1152 return efi_secureboot_mode_disabled;

1153 return efi_secureboot_mode_enabled;

1154 }

1155

1156 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE

1157 void efi_check_for_embedded_firmwares(void);

1158 #else

1159 static inline void efi_check_for_embedded_firmwares(void) { }

1160 #endif

1161

1162 #define arch_efi_call_virt(p, f, args...) ((p)->f(args))

1163

1164 /*

1165 * Arch code must implement the following three routines:

1166 *

1167 * * arch_efi_call_virt_setup()

1168 *

1169 * Sets up the environment for the call (e.g. switching page tables,

1170 * allowing kernel-mode use of floating point, if required).

1171 *

1172 * * arch_efi_call_virt()

1173 *

1174 * Performs the call. This routine takes a variable number of arguments so

1175 * it must be implemented as a variadic preprocessor macro.

1176 *

1177 * * arch_efi_call_virt_teardown()

1178 *

1179 * Restores the usual kernel environment once the call has returned.

1180 */

1181

1182 #define efi_call_virt_pointer(p, f, args...) \

1183 ({ \

1184 typeof((p)->f(args)) __s; \

1185 unsigned long __flags; \

1186 \

1187 arch_efi_call_virt_setup(); \

1188 \

1189 __flags = efi_call_virt_save_flags(); \

1190 __s = arch_efi_call_virt(p, f, args); \

1191 efi_call_virt_check_flags(__flags, NULL); \

1192 \

1193 arch_efi_call_virt_teardown(); \

1194 \

1195 __s; \

1196 })

1197

1198 #define EFI_RANDOM_SEED_SIZE 32U // BLAKE2S_HASH_SIZE

1199

1200 struct linux_efi_random_seed {

1201 u32 size;

1202 u8 bits[];

1203 };

1204

1205 struct linux_efi_tpm_eventlog {

1206 u32 size;

1207 u32 final_events_preboot_size;

1208 u8 version;

1209 u8 log[];

1210 };

1211

1212 extern int efi_tpm_eventlog_init(void);

1213

1214 struct efi_tcg2_final_events_table {

1215 u64 version;

1216 u64 nr_events;

1217 u8 events[];

1218 };

1219 extern int efi_tpm_final_log_size;

1220

1221 extern unsigned long rci2_table_phys;

1222

1223 efi_status_t

1224 efi_call_acpi_prm_handler(efi_status_t (__efiapi *handler_addr)(u64, void *),

1225 u64 param_buffer_addr, void *context);

1226

1227 /*

1228 * efi_runtime_service() function identifiers.

1229 * "NONE" is used by efi_recover_from_page_fault() to check if the page

1230 * fault happened while executing an efi runtime service.

1231 */

1232 enum efi_rts_ids {

1233 EFI_NONE,

1234 EFI_GET_TIME,

1235 EFI_SET_TIME,

1236 EFI_GET_WAKEUP_TIME,

1237 EFI_SET_WAKEUP_TIME,

1238 EFI_GET_VARIABLE,

1239 EFI_GET_NEXT_VARIABLE,

1240 EFI_SET_VARIABLE,

1241 EFI_QUERY_VARIABLE_INFO,

1242 EFI_GET_NEXT_HIGH_MONO_COUNT,

1243 EFI_RESET_SYSTEM,

1244 EFI_UPDATE_CAPSULE,

1245 EFI_QUERY_CAPSULE_CAPS,

1246 EFI_ACPI_PRM_HANDLER,

1247 };

1248

1249 union efi_rts_args;

1250

1251 /*

1252 * efi_runtime_work: Details of EFI Runtime Service work

1253 * @args: Pointer to union describing the arguments

1254 * @status: Status of executing EFI Runtime Service

1255 * @efi_rts_id: EFI Runtime Service function identifier

1256 * @efi_rts_comp: Struct used for handling completions

1257 * @caller: The caller of the runtime service

1258 */

1259 struct efi_runtime_work {

1260 union efi_rts_args *args;

1261 efi_status_t status;

1262 struct work_struct work;

1263 enum efi_rts_ids efi_rts_id;

1264 struct completion efi_rts_comp;

1265 const void *caller;

1266 };

1267

1268 extern struct efi_runtime_work efi_rts_work;

1269

1270 /* Workqueue to queue EFI Runtime Services */

1271 extern struct workqueue_struct *efi_rts_wq;

1272

1273 struct linux_efi_memreserve {

1274 int size; // allocated size of the array

1275 atomic_t count; // number of entries used

1276 phys_addr_t next; // pa of next struct instance

1277 struct {

1278 phys_addr_t base;

1279 phys_addr_t size;

1280 } entry[];

1281 };

1282

1283 #define EFI_MEMRESERVE_COUNT(size) (((size) - sizeof(struct linux_efi_memreserve)) \

1284 / sizeof_field(struct linux_efi_memreserve, entry[0]))

1285

1286 void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size);

1287

1288 /*

1289 * The LINUX_EFI_MOK_VARIABLE_TABLE_GUID config table can be provided

1290 * to the kernel by an EFI boot loader. The table contains a packed

1291 * sequence of these entries, one for each named MOK variable.

1292 * The sequence is terminated by an entry with a completely NULL

1293 * name and 0 data size.

1294 */

1295 struct efi_mokvar_table_entry {

1296 char name[256];

1297 u64 data_size;

1298 u8 data[];

1299 } __attribute((packed));

1300

1301 #ifdef CONFIG_LOAD_UEFI_KEYS

1302 extern void __init efi_mokvar_table_init(void);

1303 extern struct efi_mokvar_table_entry *efi_mokvar_entry_next(

1304 struct efi_mokvar_table_entry **mokvar_entry);

1305 extern struct efi_mokvar_table_entry *efi_mokvar_entry_find(const char *name);

1306 #else

1307 static inline void efi_mokvar_table_init(void) { }

1308 static inline struct efi_mokvar_table_entry *efi_mokvar_entry_next(

1309 struct efi_mokvar_table_entry **mokvar_entry)

1310 {

1311 return NULL;

1312 }

1313 static inline struct efi_mokvar_table_entry *efi_mokvar_entry_find(

1314 const char *name)

1315 {

1316 return NULL;

1317 }

1318 #endif

1319

1320 extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);

1321

1322 struct linux_efi_coco_secret_area {

1323 u64 base_pa;

1324 u64 size;

1325 };

1326

1327 struct linux_efi_initrd {

1328 unsigned long base;

1329 unsigned long size;

1330 };

1331

1332 /* Header of a populated EFI secret area */

1333 #define EFI_SECRET_TABLE_HEADER_GUID EFI_GUID(0x1e74f542, 0x71dd, 0x4d66, 0x96, 0x3e, 0xef, 0x42, 0x87, 0xff, 0x17, 0x3b)

1334

1335 bool xen_efi_config_table_is_usable(const efi_guid_t *guid, unsigned long table);

1336

1337 static inline

1338 bool efi_config_table_is_usable(const efi_guid_t *guid, unsigned long table)

1339 {

1340 if (!IS_ENABLED(CONFIG_XEN_EFI))

1341 return true;

1342 return xen_efi_config_table_is_usable(guid, table);

1343 }

1344

1345 umode_t efi_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n);

1346

1347 /*

1348 * efivar ops event type

1349 */

1350 #define EFIVAR_OPS_RDONLY 0

1351 #define EFIVAR_OPS_RDWR 1

1352

1353 extern struct blocking_notifier_head efivar_ops_nh;

1354

1355 void efivars_generic_ops_register(void);

1356 void efivars_generic_ops_unregister(void);

1357

1358 #endif /* _LINUX_EFI_H */