Debian Codegraph @

.cargo/vendor/r-efi/src/hii.rs

raw
1 //! Human Interface Infrastructure (HII)
2 //!
3 //! This module contains bindings and definitions copied from Section 33.3 of
4 //! the UEFI spec, as well as the core HII related definitions.
5
6 //
7 // Core HII Definitions
8 //
9
10 // This is the exception to the rule. It's defined in 34.8 (HII_DATABASE
11 // protocol), not 33.3, but it's used throughout the HII protocols, so it makes
12 // sense to be defined at the base.
13 pub type Handle = *mut core::ffi::c_void;
14
15 //
16 // 33.3.1 Package Lists and Package Headers
17 //
18
19 #[repr(C)]
20 #[derive(Clone, Copy, Debug)]
21 pub struct PackageHeader<const N: usize = 0> {
22 pub length: [u8; 3],
23 pub r#type: u8,
24 pub data: [u8; N],
25 }
26
27 pub const PACKAGE_TYPE_ALL: u8 = 0x00;
28 pub const PACKAGE_TYPE_GUID: u8 = 0x01;
29 pub const PACKAGE_FORMS: u8 = 0x02;
30 pub const PACKAGE_STRINGS: u8 = 0x04;
31 pub const PACKAGE_FONTS: u8 = 0x05;
32 pub const PACKAGE_IMAGES: u8 = 0x06;
33 pub const PACKAGE_SIMPLE_FONTS: u8 = 0x07;
34 pub const PACKAGE_DEVICE_PATH: u8 = 0x08;
35 pub const PACKAGE_KEYBOARD_LAYOUT: u8 = 0x09;
36 pub const PACKAGE_ANIMATIONS: u8 = 0x0A;
37 pub const PACKAGE_END: u8 = 0xDF;
38 pub const PACKAGE_TYPE_SYSTEM_BEGIN: u8 = 0xE0;
39 pub const PACKAGE_TYPE_SYSTEM_END: u8 = 0xFF;
40
41 #[repr(C)]
42 #[derive(Clone, Copy, Debug)]
43 pub struct PackageListHeader {
44 pub package_list_guid: crate::base::Guid,
45 pub package_length: u32,
46 }
47
48 //
49 // 33.3.3 Font Package
50 //
51
52 #[repr(C)]
53 #[derive(Clone, Copy, Debug)]
54 pub struct FontPackageHdr<const N: usize = 0> {
55 pub header: PackageHeader,
56 pub hdr_size: u32,
57 pub glyph_block_offset: u32,
58 pub cell: GlyphInfo,
59 pub font_style: FontStyle,
60 pub font_family: [crate::base::Char16; N],
61 }
62
63 pub type FontStyle = u32;
64
65 pub const FONT_STYLE_NORMAL: FontStyle = 0x00000000;
66 pub const FONT_STYLE_BOLD: FontStyle = 0x00000001;
67 pub const FONT_STYLE_ITALIC: FontStyle = 0x00000002;
68 pub const FONT_STYLE_EMBOSS: FontStyle = 0x00010000;
69 pub const FONT_STYLE_OUTLINE: FontStyle = 0x00020000;
70 pub const FONT_STYLE_SHADOW: FontStyle = 0x00040000;
71 pub const FONT_STYLE_UNDERLINE: FontStyle = 0x00080000;
72 pub const FONT_STYLE_DBL_UNDER: FontStyle = 0x00100000;
73
74 #[repr(C)]
75 #[derive(Clone, Copy, Debug)]
76 pub struct GlyphBlock<const N: usize = 0> {
77 pub block_type: u8,
78 pub block_body: [u8; N],
79 }
80
81 pub const GIBT_END: u8 = 0x00;
82 pub const GIBT_GLYPH: u8 = 0x10;
83 pub const GIBT_GLYPHS: u8 = 0x11;
84 pub const GIBT_GLYPH_DEFAULT: u8 = 0x12;
85 pub const GIBT_GLYPHS_DEFAULT: u8 = 0x13;
86 pub const GIBT_GLYPH_VARIABILITY: u8 = 0x14;
87 pub const GIBT_DUPLICATE: u8 = 0x20;
88 pub const GIBT_SKIP2: u8 = 0x21;
89 pub const GIBT_SKIP1: u8 = 0x22;
90 pub const GIBT_DEFAULTS: u8 = 0x23;
91 pub const GIBT_EXT1: u8 = 0x30;
92 pub const GIBT_EXT2: u8 = 0x31;
93 pub const GIBT_EXT4: u8 = 0x32;
94
95 #[repr(C)]
96 #[derive(Clone, Copy, Debug)]
97 pub struct GlyphInfo {
98 pub width: u16,
99 pub height: u16,
100 pub offset_x: i16,
101 pub offset_y: i16,
102 pub advance_x: i16,
103 }
104
105 #[repr(C)]
106 #[derive(Clone, Copy, Debug)]
107 pub struct GibtDefaultsBlock {
108 pub header: GlyphBlock,
109 pub cell: GlyphInfo,
110 }
111
112 #[repr(C)]
113 #[derive(Clone, Copy, Debug)]
114 pub struct GibtDuplicateBlock {
115 pub header: GlyphBlock,
116 pub char_value: crate::base::Char16,
117 }
118
119 #[repr(C)]
120 #[derive(Clone, Copy, Debug)]
121 pub struct GlyphGibtEndBlock {
122 pub header: GlyphBlock,
123 }
124
125 #[repr(C)]
126 #[derive(Clone, Copy, Debug)]
127 pub struct GibtExt1Block {
128 pub header: GlyphBlock,
129 pub block_type_2: u8,
130 pub length: u8,
131 }
132
133 #[repr(C)]
134 #[derive(Clone, Copy, Debug)]
135 pub struct GibtExt2Block {
136 pub header: GlyphBlock,
137 pub block_type_2: u8,
138 pub length: u16,
139 }
140
141 #[repr(C)]
142 #[derive(Clone, Copy, Debug)]
143 pub struct GibtExt4Block {
144 pub header: GlyphBlock,
145 pub block_type_2: u8,
146 pub length: u32,
147 }
148
149 #[repr(C)]
150 #[derive(Clone, Copy, Debug)]
151 pub struct GibtGlyphBlock<const N: usize = 0> {
152 pub header: GlyphBlock,
153 pub cell: GlyphInfo,
154 pub bitmap_data: [u8; N],
155 }
156
157 #[repr(C)]
158 #[derive(Clone, Copy, Debug)]
159 pub struct GibtGlyphsBlock<const N: usize = 0> {
160 pub header: GlyphBlock,
161 pub cell: GlyphInfo,
162 pub count: u16,
163 pub bitmap_data: [u8; N],
164 }
165
166 #[repr(C)]
167 #[derive(Clone, Copy, Debug)]
168 pub struct GibtGlyphDefaultBlock<const N: usize = 0> {
169 pub header: GlyphBlock,
170 pub bitmap_data: [u8; N],
171 }
172
173 #[repr(C)]
174 #[derive(Clone, Copy, Debug)]
175 pub struct GibtGlypshDefaultBlock<const N: usize = 0> {
176 pub header: GlyphBlock,
177 pub count: u16,
178 pub bitmap_data: [u8; N],
179 }
180
181 #[repr(C)]
182 #[derive(Clone, Copy, Debug)]
183 pub struct GibtSkip2Block {
184 pub header: GlyphBlock,
185 pub skip_count: u16,
186 }
187
188 #[repr(C)]
189 #[derive(Clone, Copy, Debug)]
190 pub struct GibtSkip1Block {
191 pub header: GlyphBlock,
192 pub skip_count: u8,
193 }
194
195 #[repr(C)]
196 #[derive(Clone, Copy, Debug)]
197 pub struct GibtVariabilityBlock<const N: usize = 0> {
198 pub header: GlyphBlock,
199 pub cell: GlyphInfo,
200 pub glyph_pack_in_bits: u8,
201 pub bitmap_data: [u8; N],
202 }
203
204 //
205 // 33.3.8 Forms Package
206 //
207
208 #[repr(C)]
209 #[derive(Clone, Copy, Debug)]
210 pub struct FormPackageHdr {
211 pub header: PackageHeader,
212 pub op_code_header: IfrOpHeader,
213 // Op-Codes Follow...
214 }
215
216 #[repr(C)]
217 #[derive(Clone, Copy, Debug)]
218 pub struct IfrOpHeader {
219 pub op_code: u8,
220 pub length_and_scope: u8, // Length:7, Scope:1
221 }
222
223 pub type QuestionId = u16;
224 pub type ImageId = u16;
225 pub type StringId = u16;
226 pub type FormId = u16;
227 pub type VarstoreId = u16;
228 pub type AnimationId = u16;
229
230 #[repr(C)]
231 #[derive(Clone, Copy)]
232 pub struct IfrQuestionHeader {
233 pub header: IfrStatementHeader,
234 pub question_id: QuestionId,
235 pub var_store_id: VarstoreId,
236 pub var_store_info: IfrQuestionHeaderVarstoreInfo,
237 pub flags: u8,
238 }
239
240 #[repr(C)]
241 #[derive(Clone, Copy)]
242 pub union IfrQuestionHeaderVarstoreInfo {
243 pub var_name: StringId,
244 pub var_offset: u16,
245 }
246
247 pub const IFR_FLAG_READ_ONLY: u8 = 0x01;
248 pub const IFR_FLAG_CALLBACK: u8 = 0x04;
249 pub const IFR_FLAG_RESET_REQUIRED: u8 = 0x10;
250 pub const IFR_FLAG_REST_STYLE: u8 = 0x20;
251 pub const IFR_FLAG_RECONNECT_REQUIRED: u8 = 0x40;
252 pub const IFR_FLAG_OPTIONS_ONLY: u8 = 0x80;
253
254 #[repr(C)]
255 #[derive(Clone, Copy, Debug)]
256 pub struct IfrStatementHeader {
257 pub prompt: StringId,
258 pub help: StringId,
259 }
260
261 pub const IFR_FORM_OP: u8 = 0x01;
262 pub const IFR_SUBTITLE_OP: u8 = 0x02;
263 pub const IFR_TEXT_OP: u8 = 0x03;
264 pub const IFR_IMAGE_OP: u8 = 0x04;
265 pub const IFR_ONE_OF_OP: u8 = 0x05;
266 pub const IFR_CHECKBOX_OP: u8 = 0x06;
267 pub const IFR_NUMERIC_OP: u8 = 0x07;
268 pub const IFR_PASSWORD_OP: u8 = 0x08;
269 pub const IFR_ONE_OF_OPTION_OP: u8 = 0x09;
270 pub const IFR_SUPPRESS_IF_OP: u8 = 0x0A;
271 pub const IFR_LOCKED_OP: u8 = 0x0B;
272 pub const IFR_ACTION_OP: u8 = 0x0C;
273 pub const IFR_RESET_BUTTON_OP: u8 = 0x0D;
274 pub const IFR_FORM_SET_OP: u8 = 0x0E;
275 pub const IFR_REF_OP: u8 = 0x0F;
276 pub const IFR_NO_SUBMIT_IF_OP: u8 = 0x10;
277 pub const IFR_INCONSISTENT_IF_OP: u8 = 0x11;
278 pub const IFR_EQ_ID_VAL_OP: u8 = 0x12;
279 pub const IFR_EQ_ID_ID_OP: u8 = 0x13;
280 pub const IFR_EQ_ID_VAL_LIST_OP: u8 = 0x14;
281 pub const IFR_AND_OP: u8 = 0x15;
282 pub const IFR_OR_OP: u8 = 0x16;
283 pub const IFR_NOT_OP: u8 = 0x17;
284 pub const IFR_RULE_OP: u8 = 0x18;
285 pub const IFR_GRAY_OUT_IF_OP: u8 = 0x19;
286 pub const IFR_DATE_OP: u8 = 0x1A;
287 pub const IFR_TIME_OP: u8 = 0x1B;
288 pub const IFR_STRING_OP: u8 = 0x1C;
289 pub const IFR_REFRESH_OP: u8 = 0x1D;
290 pub const IFR_DISABLE_IF_OP: u8 = 0x1E;
291 pub const IFR_ANIMATION_OP: u8 = 0x1F;
292 pub const IFR_TO_LOWER_OP: u8 = 0x20;
293 pub const IFR_TO_UPPER_OP: u8 = 0x21;
294 pub const IFR_MAP_OP: u8 = 0x22;
295 pub const IFR_ORDERED_LIST_OP: u8 = 0x23;
296 pub const IFR_VARSTORE_OP: u8 = 0x24;
297 pub const IFR_VARSTORE_NAME_VALUE_OP: u8 = 0x25;
298 pub const IFR_VARSTORE_EFI_OP: u8 = 0x26;
299 pub const IFR_VARSTORE_DEVICE_OP: u8 = 0x27;
300 pub const IFR_VERSION_OP: u8 = 0x28;
301 pub const IFR_END_OP: u8 = 0x29;
302 pub const IFR_MATCH_OP: u8 = 0x2A;
303 pub const IFR_GET_OP: u8 = 0x2B;
304 pub const IFR_SET_OP: u8 = 0x2C;
305 pub const IFR_READ_OP: u8 = 0x2D;
306 pub const IFR_WRITE_OP: u8 = 0x2E;
307 pub const IFR_EQUAL_OP: u8 = 0x2F;
308 pub const IFR_NOT_EQUAL_OP: u8 = 0x30;
309 pub const IFR_GREATER_THAN_OP: u8 = 0x31;
310 pub const IFR_GREATER_EQUAL_OP: u8 = 0x32;
311 pub const IFR_LESS_THAN_OP: u8 = 0x33;
312 pub const IFR_LESS_EQUAL_OP: u8 = 0x34;
313 pub const IFR_BITWISE_AND_OP: u8 = 0x35;
314 pub const IFR_BITWISE_OR_OP: u8 = 0x36;
315 pub const IFR_BITWISE_NOT_OP: u8 = 0x37;
316 pub const IFR_SHIFT_LEFT_OP: u8 = 0x38;
317 pub const IFR_SHIFT_RIGHT_OP: u8 = 0x39;
318 pub const IFR_ADD_OP: u8 = 0x3A;
319 pub const IFR_SUBTRACT_OP: u8 = 0x3B;
320 pub const IFR_MULTIPLY_OP: u8 = 0x3C;
321 pub const IFR_DIVIDE_OP: u8 = 0x3D;
322 pub const IFR_MODULO_OP: u8 = 0x3E;
323 pub const IFR_RULE_REF_OP: u8 = 0x3F;
324 pub const IFR_QUESTION_REF1_OP: u8 = 0x40;
325 pub const IFR_QUESTION_REF2_OP: u8 = 0x41;
326 pub const IFR_UINT8_OP: u8 = 0x42;
327 pub const IFR_UINT16_OP: u8 = 0x43;
328 pub const IFR_UINT32_OP: u8 = 0x44;
329 pub const IFR_UINT64_OP: u8 = 0x45;
330 pub const IFR_TRUE_OP: u8 = 0x46;
331 pub const IFR_FALSE_OP: u8 = 0x47;
332 pub const IFR_TO_UINT_OP: u8 = 0x48;
333 pub const IFR_TO_STRING_OP: u8 = 0x49;
334 pub const IFR_TO_BOOLEAN_OP: u8 = 0x4A;
335 pub const IFR_MID_OP: u8 = 0x4B;
336 pub const IFR_FIND_OP: u8 = 0x4C;
337 pub const IFR_TOKEN_OP: u8 = 0x4D;
338 pub const IFR_STRING_REF1_OP: u8 = 0x4E;
339 pub const IFR_STRING_REF2_OP: u8 = 0x4F;
340 pub const IFR_CONDITIONAL_OP: u8 = 0x50;
341 pub const IFR_QUESTION_REF3_OP: u8 = 0x51;
342 pub const IFR_ZERO_OP: u8 = 0x52;
343 pub const IFR_ONE_OP: u8 = 0x53;
344 pub const IFR_ONES_OP: u8 = 0x54;
345 pub const IFR_UNDEFINED_OP: u8 = 0x55;
346 pub const IFR_LENGTH_OP: u8 = 0x56;
347 pub const IFR_DUP_OP: u8 = 0x57;
348 pub const IFR_THIS_OP: u8 = 0x58;
349 pub const IFR_SPAN_OP: u8 = 0x59;
350 pub const IFR_VALUE_OP: u8 = 0x5A;
351 pub const IFR_DEFAULT_OP: u8 = 0x5B;
352 pub const IFR_DEFAULTSTORE_OP: u8 = 0x5C;
353 pub const IFR_FORM_MAP_OP: u8 = 0x5D;
354 pub const IFR_CATENATE_OP: u8 = 0x5E;
355 pub const IFR_GUID_OP: u8 = 0x5F;
356 pub const IFR_SECURITY_OP: u8 = 0x60;
357 pub const IFR_MODAL_TAG_OP: u8 = 0x61;
358 pub const IFR_REFRESH_ID_OP: u8 = 0x62;
359 pub const IFR_WARNING_IF_OP: u8 = 0x63;
360 pub const IFR_MATCH2_OP: u8 = 0x64;
361
362 #[repr(C)]
363 #[derive(Clone, Copy)]
364 pub struct IfrAction {
365 pub header: IfrOpHeader,
366 pub question: IfrQuestionHeader,
367 pub question_config: StringId,
368 }
369
370 #[repr(C)]
371 #[derive(Clone, Copy)]
372 pub struct IfrAction1 {
373 pub header: IfrOpHeader,
374 pub question: IfrQuestionHeader,
375 }
376
377 #[repr(C)]
378 #[derive(Clone, Copy, Debug)]
379 pub struct IfrAnimation {
380 pub header: IfrOpHeader,
381 pub id: AnimationId,
382 }
383
384 #[repr(C)]
385 #[derive(Clone, Copy, Debug)]
386 pub struct IfrAdd {
387 pub header: IfrOpHeader,
388 }
389
390 #[repr(C)]
391 #[derive(Clone, Copy, Debug)]
392 pub struct IfrAnd {
393 pub header: IfrOpHeader,
394 }
395
396 #[repr(C)]
397 #[derive(Clone, Copy, Debug)]
398 pub struct IfrBitwiseAnd {
399 pub header: IfrOpHeader,
400 }
401
402 #[repr(C)]
403 #[derive(Clone, Copy, Debug)]
404 pub struct IfrBitwiseNot {
405 pub header: IfrOpHeader,
406 }
407
408 #[repr(C)]
409 #[derive(Clone, Copy, Debug)]
410 pub struct IfrBitwiseOr {
411 pub header: IfrOpHeader,
412 }
413
414 #[repr(C)]
415 #[derive(Clone, Copy, Debug)]
416 pub struct IfrCatenate {
417 pub header: IfrOpHeader,
418 }
419
420 #[repr(C)]
421 #[derive(Clone, Copy)]
422 pub struct IfrCheckbox {
423 pub header: IfrOpHeader,
424 pub question: IfrQuestionHeader,
425 pub flags: u8,
426 }
427
428 pub const IFR_CHECKBOX_DEFAULT: u8 = 0x01;
429 pub const IFR_CHECKBOX_DEFAULT_MFG: u8 = 0x02;
430
431 #[repr(C)]
432 #[derive(Clone, Copy, Debug)]
433 pub struct IfrConditional {
434 pub header: IfrOpHeader,
435 }
436
437 #[repr(C)]
438 #[derive(Clone, Copy)]
439 pub struct IfrDate {
440 pub header: IfrOpHeader,
441 pub question: IfrQuestionHeader,
442 pub flags: u8,
443 }
444
445 pub const QF_DATE_YEAR_SUPPRESS: u8 = 0x01;
446 pub const QF_DATE_MONTH_SUPPRESS: u8 = 0x02;
447 pub const QF_DATE_DAY_SUPPRESS: u8 = 0x04;
448 pub const QF_DATE_STORAGE: u8 = 0x30;
449
450 pub const QF_DATE_STORAGE_NORMAL: u8 = 0x00;
451 pub const QF_DATE_STORAGE_TIME: u8 = 0x10;
452 pub const QF_DATE_STORAGE_WAKEUP: u8 = 0x20;
453
454 #[repr(C)]
455 #[derive(Clone, Copy)]
456 pub struct IfrDefault {
457 pub header: IfrOpHeader,
458 pub default_id: u16,
459 pub r#type: u8,
460 pub value: IfrTypeValue,
461 }
462
463 #[repr(C)]
464 #[derive(Clone, Copy, Debug)]
465 pub struct IfrDefault2 {
466 pub header: IfrOpHeader,
467 pub default_id: u16,
468 pub r#type: u8,
469 }
470
471 #[repr(C)]
472 #[derive(Clone, Copy, Debug)]
473 pub struct IfrDefaultstore {
474 pub header: IfrOpHeader,
475 pub default_name: StringId,
476 pub default_id: u16,
477 }
478
479 #[repr(C)]
480 #[derive(Clone, Copy, Debug)]
481 pub struct IfrDisableIf {
482 pub header: IfrOpHeader,
483 }
484
485 #[repr(C)]
486 #[derive(Clone, Copy, Debug)]
487 pub struct IfrDivide {
488 pub header: IfrOpHeader,
489 }
490
491 #[repr(C)]
492 #[derive(Clone, Copy, Debug)]
493 pub struct IfrDup {
494 pub header: IfrOpHeader,
495 }
496
497 #[repr(C)]
498 #[derive(Clone, Copy, Debug)]
499 pub struct IfrEnd {
500 pub header: IfrOpHeader,
501 }
502
503 #[repr(C)]
504 #[derive(Clone, Copy, Debug)]
505 pub struct IfrEqual {
506 pub header: IfrOpHeader,
507 }
508
509 #[repr(C)]
510 #[derive(Clone, Copy, Debug)]
511 pub struct IfrEqIdId {
512 pub header: IfrOpHeader,
513 pub question_id_1: QuestionId,
514 pub question_id_2: QuestionId,
515 }
516
517 #[repr(C)]
518 #[derive(Clone, Copy, Debug)]
519 pub struct IfrEqIdValList<const N: usize = 0> {
520 pub header: IfrOpHeader,
521 pub question_id: QuestionId,
522 pub list_length: u16,
523 pub value_list: [u16; N],
524 }
525
526 #[repr(C)]
527 #[derive(Clone, Copy, Debug)]
528 pub struct IfrEqIdVal {
529 pub header: IfrOpHeader,
530 pub question_id: QuestionId,
531 pub value: u16,
532 }
533
534 #[repr(C)]
535 #[derive(Clone, Copy, Debug)]
536 pub struct IfrFalse {
537 pub header: IfrOpHeader,
538 }
539
540 #[repr(C)]
541 #[derive(Clone, Copy, Debug)]
542 pub struct IfrFind {
543 pub header: IfrOpHeader,
544 pub format: u8,
545 }
546
547 pub const IFR_FF_CASE_SENSITIVE: u8 = 0x00;
548 pub const IFR_FF_CASE_INSENSITIVE: u8 = 0x01;
549
550 #[repr(C)]
551 #[derive(Clone, Copy, Debug)]
552 pub struct IfrForm {
553 pub header: IfrOpHeader,
554 pub form_id: FormId,
555 pub form_title: StringId,
556 }
557
558 #[repr(C)]
559 #[derive(Clone, Copy, Debug)]
560 pub struct IfrFormMapMethod {
561 pub method_title: StringId,
562 pub method_identifier: crate::base::Guid,
563 }
564
565 #[repr(C)]
566 #[derive(Clone, Copy, Debug)]
567 pub struct IfrFormMap<const N: usize = 0> {
568 pub header: IfrOpHeader,
569 pub form_id: FormId,
570 pub methods: [IfrFormMapMethod; N],
571 }
572
573 pub const STANDARD_FORM_GUID: crate::base::Guid = crate::base::Guid::from_fields(
574 0x3bd2f4ec,
575 0xe524,
576 0x46e4,
577 0xa9,
578 0xd8,
579 &[0x51, 0x01, 0x17, 0x42, 0x55, 0x62],
580 );
581
582 #[repr(C)]
583 #[derive(Clone, Copy, Debug)]
584 pub struct IfrFormSet<const N: usize = 0> {
585 pub header: IfrOpHeader,
586 pub guid: crate::base::Guid,
587 pub form_set_title: StringId,
588 pub help: StringId,
589 pub flags: u8,
590 pub class_guid: [crate::base::Guid; N],
591 }
592
593 #[repr(C)]
594 #[derive(Clone, Copy)]
595 pub struct IfrGet {
596 pub header: IfrOpHeader,
597 pub var_store_id: VarstoreId,
598 pub var_store_info: IfrGetVarStoreInfo,
599 pub var_store_type: u8,
600 }
601
602 #[repr(C)]
603 #[derive(Clone, Copy)]
604 pub union IfrGetVarStoreInfo {
605 pub var_name: StringId,
606 pub var_offset: u16,
607 }
608
609 #[repr(C)]
610 #[derive(Clone, Copy, Debug)]
611 pub struct IfrGrayOutIf {
612 pub header: IfrOpHeader,
613 }
614
615 #[repr(C)]
616 #[derive(Clone, Copy, Debug)]
617 pub struct IfrGreaterEqual {
618 pub header: IfrOpHeader,
619 }
620
621 #[repr(C)]
622 #[derive(Clone, Copy, Debug)]
623 pub struct IfrGreaterThan {
624 pub header: IfrOpHeader,
625 }
626
627 #[repr(C)]
628 #[derive(Clone, Copy, Debug)]
629 pub struct IfrGuid {
630 pub header: IfrOpHeader,
631 pub guid: crate::base::Guid,
632 }
633
634 #[repr(C)]
635 #[derive(Clone, Copy, Debug)]
636 pub struct IfrImage {
637 pub id: ImageId,
638 }
639
640 #[repr(C)]
641 #[derive(Clone, Copy, Debug)]
642 pub struct IfrInconsistentIf {
643 pub header: IfrOpHeader,
644 pub error: StringId,
645 }
646
647 #[repr(C)]
648 #[derive(Clone, Copy, Debug)]
649 pub struct IfrLength {
650 pub header: IfrOpHeader,
651 }
652
653 #[repr(C)]
654 #[derive(Clone, Copy, Debug)]
655 pub struct IfrLessEqual {
656 pub header: IfrOpHeader,
657 }
658
659 #[repr(C)]
660 #[derive(Clone, Copy, Debug)]
661 pub struct IfrLessThan {
662 pub header: IfrOpHeader,
663 }
664
665 #[repr(C)]
666 #[derive(Clone, Copy, Debug)]
667 pub struct IfrLocked {
668 pub header: IfrOpHeader,
669 }
670
671 #[repr(C)]
672 #[derive(Clone, Copy, Debug)]
673 pub struct IfrMap {
674 pub header: IfrOpHeader,
675 }
676
677 #[repr(C)]
678 #[derive(Clone, Copy, Debug)]
679 pub struct IfrMatch {
680 pub header: IfrOpHeader,
681 }
682
683 #[repr(C)]
684 #[derive(Clone, Copy, Debug)]
685 pub struct IfrMid {
686 pub header: IfrOpHeader,
687 }
688
689 #[repr(C)]
690 #[derive(Clone, Copy, Debug)]
691 pub struct IfrModalTag {
692 pub header: IfrOpHeader,
693 }
694
695 #[repr(C)]
696 #[derive(Clone, Copy, Debug)]
697 pub struct IfrModulo {
698 pub header: IfrOpHeader,
699 }
700
701 #[repr(C)]
702 #[derive(Clone, Copy, Debug)]
703 pub struct IfrMultiply {
704 pub header: IfrOpHeader,
705 }
706
707 #[repr(C)]
708 #[derive(Clone, Copy, Debug)]
709 pub struct IfrNot {
710 pub header: IfrOpHeader,
711 }
712
713 #[repr(C)]
714 #[derive(Clone, Copy, Debug)]
715 pub struct IfrNotEqual {
716 pub header: IfrOpHeader,
717 }
718
719 #[repr(C)]
720 #[derive(Clone, Copy, Debug)]
721 pub struct IfrNoSubmitIf {
722 pub header: IfrOpHeader,
723 pub error: StringId,
724 }
725
726 #[repr(C)]
727 #[derive(Clone, Copy, Debug)]
728 pub struct IfrNumericDataU8 {
729 pub min_value: u8,
730 pub max_value: u8,
731 pub step: u8,
732 }
733
734 #[repr(C)]
735 #[derive(Clone, Copy, Debug)]
736 pub struct IfrNumericDataU16 {
737 pub min_value: u16,
738 pub max_value: u16,
739 pub step: u16,
740 }
741
742 #[repr(C)]
743 #[derive(Clone, Copy, Debug)]
744 pub struct IfrNumericDataU32 {
745 pub min_value: u32,
746 pub max_value: u32,
747 pub step: u32,
748 }
749
750 #[repr(C)]
751 #[derive(Clone, Copy, Debug)]
752 pub struct IfrNumericDataU64 {
753 pub min_value: u64,
754 pub max_value: u64,
755 pub step: u64,
756 }
757
758 #[repr(C)]
759 #[derive(Clone, Copy)]
760 pub union IfrNumericData {
761 pub r#u8: IfrNumericDataU8,
762 pub r#u16: IfrNumericDataU16,
763 pub r#u32: IfrNumericDataU32,
764 pub r#u64: IfrNumericDataU64,
765 }
766
767 #[repr(C)]
768 #[derive(Clone, Copy)]
769 pub struct IfrNumeric {
770 pub header: IfrOpHeader,
771 pub question: IfrQuestionHeader,
772 pub flags: u8,
773 pub data: IfrNumericData,
774 }
775
776 pub const IFR_NUMERIC_SIZE: u8 = 0x03;
777 pub const IFR_NUMERIC_SIZE_1: u8 = 0x00;
778 pub const IFR_NUMERIC_SIZE_2: u8 = 0x01;
779 pub const IFR_NUMERIC_SIZE_4: u8 = 0x02;
780 pub const IFR_NUMERIC_SIZE_8: u8 = 0x03;
781
782 pub const IFR_DISPLAY: u8 = 0x30;
783 pub const IFR_DISPLAY_INT_DEC: u8 = 0x00;
784 pub const IFR_DISPLAY_UINT_DEC: u8 = 0x10;
785 pub const IFR_DISPLAY_UINT_HEX: u8 = 0x20;
786
787 #[repr(C)]
788 #[derive(Clone, Copy, Debug)]
789 pub struct IfrOne {
790 pub header: IfrOpHeader,
791 }
792
793 #[repr(C)]
794 #[derive(Clone, Copy, Debug)]
795 pub struct IfrOnes {
796 pub header: IfrOpHeader,
797 }
798
799 type IfrOneOfData = IfrNumericData;
800
801 #[repr(C)]
802 #[derive(Clone, Copy)]
803 pub struct IfrOneOf {
804 pub header: IfrOpHeader,
805 pub question: IfrQuestionHeader,
806 pub flags: u8,
807 pub data: IfrOneOfData,
808 }
809
810 #[repr(C)]
811 #[derive(Clone, Copy)]
812 pub struct IfrOneOfOption {
813 pub header: IfrOpHeader,
814 pub option: StringId,
815 pub flags: u8,
816 pub r#type: u8,
817 pub value: IfrTypeValue,
818 }
819
820 #[repr(C)]
821 #[derive(Clone, Copy)]
822 pub union IfrTypeValue<const N: usize = 0> {
823 pub r#u8: u8,
824 pub r#u16: u16,
825 pub r#u32: u32,
826 pub r#u64: u64,
827 pub b: crate::base::Boolean,
828 pub time: Time,
829 pub date: Date,
830 pub string: StringId,
831 pub r#ref: Ref,
832 pub buffer: [u8; N],
833 }
834
835 #[repr(C)]
836 #[derive(Clone, Copy, Debug)]
837 pub struct Time {
838 pub hour: u8,
839 pub minute: u8,
840 pub second: u8,
841 }
842
843 #[repr(C)]
844 #[derive(Clone, Copy, Debug)]
845 pub struct Date {
846 pub year: u16,
847 pub month: u8,
848 pub day: u8,
849 }
850
851 #[repr(C)]
852 #[derive(Clone, Copy, Debug)]
853 pub struct Ref {
854 pub question_id: QuestionId,
855 pub form_id: FormId,
856 pub form_set_guid: crate::base::Guid,
857 pub device_path: StringId,
858 }
859
860 pub const IFR_TYPE_NUM_SIZE_8: u8 = 0x00;
861 pub const IFR_TYPE_NUM_SIZE_16: u8 = 0x01;
862 pub const IFR_TYPE_NUM_SIZE_32: u8 = 0x02;
863 pub const IFR_TYPE_NUM_SIZE_64: u8 = 0x03;
864 pub const IFR_TYPE_BOOLEAN: u8 = 0x04;
865 pub const IFR_TYPE_TIME: u8 = 0x05;
866 pub const IFR_TYPE_DATE: u8 = 0x06;
867 pub const IFR_TYPE_STRING: u8 = 0x07;
868 pub const IFR_TYPE_OTHER: u8 = 0x08;
869 pub const IFR_TYPE_UNDEFINED: u8 = 0x09;
870 pub const IFR_TYPE_ACTION: u8 = 0x0A;
871 pub const IFR_TYPE_BUFFER: u8 = 0x0B;
872 pub const IFR_TYPE_REF: u8 = 0x0C;
873
874 pub const IFR_OPTION_DEFAULT: u8 = 0x10;
875 pub const IFR_OPTION_DEFAULT_MFG: u8 = 0x20;
876
877 #[repr(C)]
878 #[derive(Clone, Copy, Debug)]
879 pub struct IfrOr {
880 pub header: IfrOpHeader,
881 }
882
883 #[repr(C)]
884 #[derive(Clone, Copy)]
885 pub struct IfrOrderedList {
886 pub header: IfrOpHeader,
887 pub question: IfrQuestionHeader,
888 pub max_containers: u8,
889 pub flags: u8,
890 }
891
892 pub const IFR_UNIQUE_SET: u8 = 0x01;
893 pub const IFR_NO_EMPTY_SET: u8 = 0x02;
894
895 #[repr(C)]
896 #[derive(Clone, Copy)]
897 pub struct IfrPassword {
898 pub header: IfrOpHeader,
899 pub question: IfrQuestionHeader,
900 pub min_size: u16,
901 pub max_size: u16,
902 }
903
904 #[repr(C)]
905 #[derive(Clone, Copy, Debug)]
906 pub struct IfrQuestionRef1 {
907 pub header: IfrOpHeader,
908 pub question_id: QuestionId,
909 }
910
911 #[repr(C)]
912 #[derive(Clone, Copy, Debug)]
913 pub struct IfrQuestionRef2 {
914 pub header: IfrOpHeader,
915 }
916
917 #[repr(C)]
918 #[derive(Clone, Copy, Debug)]
919 pub struct IfrQuestionRef3 {
920 pub header: IfrOpHeader,
921 }
922
923 #[repr(C)]
924 #[derive(Clone, Copy, Debug)]
925 pub struct IfrQuestionRef32 {
926 pub header: IfrOpHeader,
927 pub device_path: StringId,
928 }
929
930 #[repr(C)]
931 #[derive(Clone, Copy, Debug)]
932 pub struct IfrQuestionRef33 {
933 pub header: IfrOpHeader,
934 pub device_path: StringId,
935 pub guid: crate::base::Guid,
936 }
937
938 #[repr(C)]
939 #[derive(Clone, Copy, Debug)]
940 pub struct IfrRead {
941 pub header: IfrOpHeader,
942 }
943
944 #[repr(C)]
945 #[derive(Clone, Copy)]
946 pub struct IfrRef {
947 pub header: IfrOpHeader,
948 pub question: IfrQuestionHeader,
949 pub form_id: FormId,
950 }
951
952 #[repr(C)]
953 #[derive(Clone, Copy)]
954 pub struct IfrRef2 {
955 pub header: IfrOpHeader,
956 pub question: IfrQuestionHeader,
957 pub form_id: FormId,
958 pub question_id: QuestionId,
959 }
960
961 #[repr(C)]
962 #[derive(Clone, Copy)]
963 pub struct IfrRef3 {
964 pub header: IfrOpHeader,
965 pub question: IfrQuestionHeader,
966 pub form_id: FormId,
967 pub question_id: QuestionId,
968 pub form_set_id: crate::base::Guid,
969 }
970
971 #[repr(C)]
972 #[derive(Clone, Copy)]
973 pub struct IfrRef4 {
974 pub header: IfrOpHeader,
975 pub question: IfrQuestionHeader,
976 pub form_id: FormId,
977 pub question_id: QuestionId,
978 pub form_set_id: crate::base::Guid,
979 pub device_path: StringId,
980 }
981
982 #[repr(C)]
983 #[derive(Clone, Copy)]
984 pub struct IfrRef5 {
985 pub header: IfrOpHeader,
986 pub question: IfrQuestionHeader,
987 }
988
989 #[repr(C)]
990 #[derive(Clone, Copy, Debug)]
991 pub struct IfrRefresh {
992 pub header: IfrOpHeader,
993 pub refresh_interval: u8,
994 }
995
996 #[repr(C)]
997 #[derive(Clone, Copy, Debug)]
998 pub struct IfrRefreshId {
999 pub header: IfrOpHeader,
1000 pub refresh_event_group_id: crate::base::Guid,
1001 }
1002
1003 #[repr(C)]
1004 #[derive(Clone, Copy, Debug)]
1005 pub struct IfrResetButton {
1006 pub header: IfrOpHeader,
1007 pub statement: IfrStatementHeader,
1008 pub deafult_id: DefaultId,
1009 }
1010
1011 pub type DefaultId = u16;
1012
1013 #[repr(C)]
1014 #[derive(Clone, Copy, Debug)]
1015 pub struct IfrRule {
1016 pub header: IfrOpHeader,
1017 pub rule_id: u8,
1018 }
1019
1020 #[repr(C)]
1021 #[derive(Clone, Copy, Debug)]
1022 pub struct IfrRuleRef {
1023 pub header: IfrOpHeader,
1024 pub rule_id: u8,
1025 }
1026
1027 #[repr(C)]
1028 #[derive(Clone, Copy, Debug)]
1029 pub struct IfrSecurity {
1030 pub header: IfrOpHeader,
1031 pub permissions: crate::base::Guid,
1032 }
1033
1034 #[repr(C)]
1035 #[derive(Clone, Copy)]
1036 pub union IfrSetVarStoreInfo {
1037 pub var_name: StringId,
1038 pub var_offset: u16,
1039 }
1040
1041 #[repr(C)]
1042 #[derive(Clone, Copy)]
1043 pub struct IfrSet {
1044 pub header: IfrOpHeader,
1045 pub var_store_id: VarstoreId,
1046 pub var_store_info: IfrSetVarStoreInfo,
1047 pub var_store_type: u8,
1048 }
1049
1050 #[repr(C)]
1051 #[derive(Clone, Copy, Debug)]
1052 pub struct IfrShiftLeft {
1053 pub header: IfrOpHeader,
1054 }
1055
1056 #[repr(C)]
1057 #[derive(Clone, Copy, Debug)]
1058 pub struct IfrShiftRight {
1059 pub header: IfrOpHeader,
1060 }
1061
1062 #[repr(C)]
1063 #[derive(Clone, Copy, Debug)]
1064 pub struct IfrSpan {
1065 pub header: IfrOpHeader,
1066 pub flags: u8,
1067 }
1068
1069 pub const IFR_FLAGS_FIRST_MATCHING: u8 = 0x00;
1070 pub const IFR_FLAGS_FIRST_NON_MATCHING: u8 = 0x01;
1071
1072 #[repr(C)]
1073 #[derive(Clone, Copy)]
1074 pub struct IfrString {
1075 pub header: IfrOpHeader,
1076 pub question: IfrQuestionHeader,
1077 pub min_size: u8,
1078 pub max_size: u8,
1079 pub flags: u8,
1080 }
1081
1082 pub const IFR_STRING_MULTI_LINE: u8 = 0x01;
1083
1084 #[repr(C)]
1085 #[derive(Clone, Copy, Debug)]
1086 pub struct IfrStringRef1 {
1087 pub header: IfrOpHeader,
1088 pub string_id: StringId,
1089 }
1090
1091 #[repr(C)]
1092 #[derive(Clone, Copy, Debug)]
1093 pub struct IfrStringRef2 {
1094 pub header: IfrOpHeader,
1095 }
1096
1097 #[repr(C)]
1098 #[derive(Clone, Copy, Debug)]
1099 pub struct IfrSubtitle {
1100 pub header: IfrOpHeader,
1101 pub statement: IfrStatementHeader,
1102 pub flags: u8,
1103 }
1104
1105 pub const IFR_FLAGS_HORIZONTAL: u8 = 0x01;
1106
1107 #[repr(C)]
1108 #[derive(Clone, Copy, Debug)]
1109 pub struct IfrSubtract {
1110 pub header: IfrOpHeader,
1111 }
1112
1113 #[repr(C)]
1114 #[derive(Clone, Copy, Debug)]
1115 pub struct IfrSuppressIf {
1116 pub header: IfrOpHeader,
1117 }
1118
1119 #[repr(C)]
1120 #[derive(Clone, Copy, Debug)]
1121 pub struct IfrText {
1122 pub header: IfrOpHeader,
1123 pub statement: IfrStatementHeader,
1124 pub text_two: StringId,
1125 }
1126
1127 #[repr(C)]
1128 #[derive(Clone, Copy, Debug)]
1129 pub struct IfrThis {
1130 pub header: IfrOpHeader,
1131 }
1132
1133 #[repr(C)]
1134 #[derive(Clone, Copy)]
1135 pub struct IfrTime {
1136 pub header: IfrOpHeader,
1137 pub question: IfrQuestionHeader,
1138 pub flags: u8,
1139 }
1140
1141 pub const QF_TIME_HOUR_SUPPRESS: u8 = 0x01;
1142 pub const QF_TIME_MINUTE_SUPPRESS: u8 = 0x02;
1143 pub const QF_TIME_SECOND_SUPPRESS: u8 = 0x04;
1144 pub const QF_TIME_STORAGE: u8 = 0x30;
1145
1146 pub const QF_TIME_STORAGE_NORMAL: u8 = 0x00;
1147 pub const QF_TIME_STORAGE_TIME: u8 = 0x10;
1148 pub const QF_TIME_STORAGE_WAKEUP: u8 = 0x20;
1149
1150 #[repr(C)]
1151 #[derive(Clone, Copy, Debug)]
1152 pub struct IfrToken {
1153 pub header: IfrOpHeader,
1154 }
1155
1156 #[repr(C)]
1157 #[derive(Clone, Copy, Debug)]
1158 pub struct IfrToBoolean {
1159 pub header: IfrOpHeader,
1160 }
1161
1162 #[repr(C)]
1163 #[derive(Clone, Copy, Debug)]
1164 pub struct IfrToLower {
1165 pub header: IfrOpHeader,
1166 }
1167
1168 #[repr(C)]
1169 #[derive(Clone, Copy, Debug)]
1170 pub struct IfrToString {
1171 pub header: IfrOpHeader,
1172 pub format: u8,
1173 }
1174
1175 #[repr(C)]
1176 #[derive(Clone, Copy, Debug)]
1177 pub struct IfrToUint {
1178 pub header: IfrOpHeader,
1179 }
1180
1181 #[repr(C)]
1182 #[derive(Clone, Copy, Debug)]
1183 pub struct IfrToUpper {
1184 pub header: IfrOpHeader,
1185 }
1186
1187 #[repr(C)]
1188 #[derive(Clone, Copy, Debug)]
1189 pub struct IfrTrue {
1190 pub header: IfrOpHeader,
1191 }
1192
1193 #[repr(C)]
1194 #[derive(Clone, Copy, Debug)]
1195 pub struct IfrUint8 {
1196 pub header: IfrOpHeader,
1197 pub value: u8,
1198 }
1199
1200 #[repr(C)]
1201 #[derive(Clone, Copy, Debug)]
1202 pub struct IfrUint16 {
1203 pub header: IfrOpHeader,
1204 pub value: u16,
1205 }
1206
1207 #[repr(C)]
1208 #[derive(Clone, Copy, Debug)]
1209 pub struct IfrUint32 {
1210 pub header: IfrOpHeader,
1211 pub value: u32,
1212 }
1213
1214 #[repr(C)]
1215 #[derive(Clone, Copy, Debug)]
1216 pub struct IfrUint64 {
1217 pub header: IfrOpHeader,
1218 pub value: u64,
1219 }
1220
1221 #[repr(C)]
1222 #[derive(Clone, Copy, Debug)]
1223 pub struct IfrUndefined {
1224 pub header: IfrOpHeader,
1225 }
1226
1227 #[repr(C)]
1228 #[derive(Clone, Copy, Debug)]
1229 pub struct IfrValue {
1230 pub header: IfrOpHeader,
1231 }
1232
1233 #[repr(C)]
1234 #[derive(Clone, Copy, Debug)]
1235 pub struct IfrVarstore<const N: usize = 0> {
1236 pub header: IfrOpHeader,
1237 pub guid: crate::base::Guid,
1238 pub var_store_id: VarstoreId,
1239 pub size: u16,
1240 pub name: [u8; N],
1241 }
1242
1243 #[repr(C)]
1244 #[derive(Clone, Copy, Debug)]
1245 pub struct IfrVarstoreNameValue {
1246 pub header: IfrOpHeader,
1247 pub var_store_id: VarstoreId,
1248 pub guid: crate::base::Guid,
1249 }
1250
1251 #[repr(C)]
1252 #[derive(Clone, Copy, Debug)]
1253 pub struct IfrVarstoreEfi<const N: usize = 0> {
1254 pub header: IfrOpHeader,
1255 pub var_store_id: VarstoreId,
1256 pub guid: crate::base::Guid,
1257 pub attributes: u32,
1258 pub size: u16,
1259 pub name: [u8; N],
1260 }
1261
1262 #[repr(C)]
1263 #[derive(Clone, Copy, Debug)]
1264 pub struct IfrVarstoreDevice {
1265 pub header: IfrOpHeader,
1266 pub device_path: StringId,
1267 }
1268
1269 #[repr(C)]
1270 #[derive(Clone, Copy, Debug)]
1271 pub struct IfrVersion {
1272 pub header: IfrOpHeader,
1273 }
1274
1275 #[repr(C)]
1276 #[derive(Clone, Copy, Debug)]
1277 pub struct IfrWrite {
1278 pub header: IfrOpHeader,
1279 }
1280
1281 #[repr(C)]
1282 #[derive(Clone, Copy, Debug)]
1283 pub struct IfrZero {
1284 pub header: IfrOpHeader,
1285 }
1286
1287 #[repr(C)]
1288 #[derive(Clone, Copy, Debug)]
1289 pub struct IfrWarningIf {
1290 pub header: IfrOpHeader,
1291 pub warning: StringId,
1292 pub time_out: u8,
1293 }
1294
1295 #[repr(C)]
1296 #[derive(Clone, Copy, Debug)]
1297 pub struct IfrMatch2 {
1298 pub header: IfrOpHeader,
1299 pub syntax_type: crate::base::Guid,
1300 }