1pub type BOOLEAN = bool;
4pub type UINT8 = u8;
5pub type UINT16 = i16;
6pub type INT16 = i16;
7pub type UINT64 = i64;
8pub type INT64 = i64;
9pub type UINT32 = i32;
10pub type INT32 = i32;
11pub type ACPI_NATIVE_INT = INT64;
12pub type ACPI_SIZE = UINT64;
13pub type ACPI_IO_ADDRESS = UINT64;
14pub type ACPI_PHYSICAL_ADDRESS = UINT64;
15pub type ACPI_STATUS = UINT32;
16pub type ACPI_NAME = UINT32;
17pub type ACPI_STRING = *mut i8;
18pub type ACPI_HANDLE = *mut c_void;
19pub type ACPI_OWNER_ID = UINT8;
20pub type ACPI_INTEGER = UINT64;
21pub type ACPI_OBJECT_TYPE = UINT32;
22pub type ACPI_EVENT_TYPE = UINT32;
23pub type ACPI_EVENT_STATUS = UINT32;
24pub type ACPI_ADR_SPACE_TYPE = UINT8;
25pub type ACPI_SLEEP_FUNCTION =
26 ::core::option::Option<extern "C" fn(SleepState: UINT8) -> ACPI_STATUS>;
27#[repr(C)]
28#[derive(Copy)]
29pub struct Struct_acpi_sleep_functions {
30 pub LegacyFunction: ACPI_SLEEP_FUNCTION,
31 pub ExtendedFunction: ACPI_SLEEP_FUNCTION,
32}
33impl ::core::clone::Clone for Struct_acpi_sleep_functions {
34 fn clone(&self) -> Self { *self }
35}
36impl ::core::default::Default for Struct_acpi_sleep_functions {
37 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
38}
39pub type ACPI_SLEEP_FUNCTIONS = Struct_acpi_sleep_functions;
40#[repr(C)]
41#[derive(Copy)]
42pub struct Union_acpi_object {
43 pub _bindgen_data_: [u64; 3usize],
44}
45impl Union_acpi_object {
46 pub unsafe fn Type(&mut self) -> *mut ACPI_OBJECT_TYPE {
47 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
48 ::core::mem::transmute(raw.offset(0))
49 }
50 pub unsafe fn Integer(&mut self) -> *mut Struct_Unnamed1 {
51 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
52 ::core::mem::transmute(raw.offset(0))
53 }
54 pub unsafe fn String(&mut self) -> *mut Struct_Unnamed2 {
55 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
56 ::core::mem::transmute(raw.offset(0))
57 }
58 pub unsafe fn Buffer(&mut self) -> *mut Struct_Unnamed3 {
59 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
60 ::core::mem::transmute(raw.offset(0))
61 }
62 pub unsafe fn Package(&mut self) -> *mut Struct_Unnamed4 {
63 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
64 ::core::mem::transmute(raw.offset(0))
65 }
66 pub unsafe fn Reference(&mut self) -> *mut Struct_Unnamed5 {
67 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
68 ::core::mem::transmute(raw.offset(0))
69 }
70 pub unsafe fn Processor(&mut self) -> *mut Struct_Unnamed6 {
71 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
72 ::core::mem::transmute(raw.offset(0))
73 }
74 pub unsafe fn PowerResource(&mut self) -> *mut Struct_Unnamed7 {
75 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
76 ::core::mem::transmute(raw.offset(0))
77 }
78}
79impl ::core::clone::Clone for Union_acpi_object {
80 fn clone(&self) -> Self { *self }
81}
82impl ::core::default::Default for Union_acpi_object {
83 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
84}
85#[repr(C)]
86#[derive(Copy)]
87pub struct Struct_Unnamed1 {
88 pub Type: ACPI_OBJECT_TYPE,
89 pub Value: UINT64,
90}
91impl ::core::clone::Clone for Struct_Unnamed1 {
92 fn clone(&self) -> Self { *self }
93}
94impl ::core::default::Default for Struct_Unnamed1 {
95 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
96}
97#[repr(C)]
98#[derive(Copy)]
99pub struct Struct_Unnamed2 {
100 pub Type: ACPI_OBJECT_TYPE,
101 pub Length: UINT32,
102 pub Pointer: *mut i8,
103}
104impl ::core::clone::Clone for Struct_Unnamed2 {
105 fn clone(&self) -> Self { *self }
106}
107impl ::core::default::Default for Struct_Unnamed2 {
108 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
109}
110#[repr(C)]
111#[derive(Copy)]
112pub struct Struct_Unnamed3 {
113 pub Type: ACPI_OBJECT_TYPE,
114 pub Length: UINT32,
115 pub Pointer: *mut UINT8,
116}
117impl ::core::clone::Clone for Struct_Unnamed3 {
118 fn clone(&self) -> Self { *self }
119}
120impl ::core::default::Default for Struct_Unnamed3 {
121 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
122}
123#[repr(C)]
124#[derive(Copy)]
125pub struct Struct_Unnamed4 {
126 pub Type: ACPI_OBJECT_TYPE,
127 pub Count: UINT32,
128 pub Elements: *mut Union_acpi_object,
129}
130impl ::core::clone::Clone for Struct_Unnamed4 {
131 fn clone(&self) -> Self { *self }
132}
133impl ::core::default::Default for Struct_Unnamed4 {
134 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
135}
136#[repr(C)]
137#[derive(Copy)]
138pub struct Struct_Unnamed5 {
139 pub Type: ACPI_OBJECT_TYPE,
140 pub ActualType: ACPI_OBJECT_TYPE,
141 pub Handle: ACPI_HANDLE,
142}
143impl ::core::clone::Clone for Struct_Unnamed5 {
144 fn clone(&self) -> Self { *self }
145}
146impl ::core::default::Default for Struct_Unnamed5 {
147 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
148}
149#[repr(C)]
150#[derive(Copy)]
151pub struct Struct_Unnamed6 {
152 pub Type: ACPI_OBJECT_TYPE,
153 pub ProcId: UINT32,
154 pub PblkAddress: ACPI_IO_ADDRESS,
155 pub PblkLength: UINT32,
156}
157impl ::core::clone::Clone for Struct_Unnamed6 {
158 fn clone(&self) -> Self { *self }
159}
160impl ::core::default::Default for Struct_Unnamed6 {
161 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
162}
163#[repr(C)]
164#[derive(Copy)]
165pub struct Struct_Unnamed7 {
166 pub Type: ACPI_OBJECT_TYPE,
167 pub SystemLevel: UINT32,
168 pub ResourceOrder: UINT32,
169}
170impl ::core::clone::Clone for Struct_Unnamed7 {
171 fn clone(&self) -> Self { *self }
172}
173impl ::core::default::Default for Struct_Unnamed7 {
174 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
175}
176pub type ACPI_OBJECT = Union_acpi_object;
177#[repr(C)]
178#[derive(Copy)]
179pub struct Struct_acpi_object_list {
180 pub Count: UINT32,
181 pub Pointer: *mut ACPI_OBJECT,
182}
183impl ::core::clone::Clone for Struct_acpi_object_list {
184 fn clone(&self) -> Self { *self }
185}
186impl ::core::default::Default for Struct_acpi_object_list {
187 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
188}
189pub type ACPI_OBJECT_LIST = Struct_acpi_object_list;
190#[repr(C)]
191#[derive(Copy)]
192pub struct Struct_acpi_buffer {
193 pub Length: ACPI_SIZE,
194 pub Pointer: *mut c_void,
195}
196impl ::core::clone::Clone for Struct_acpi_buffer {
197 fn clone(&self) -> Self { *self }
198}
199impl ::core::default::Default for Struct_acpi_buffer {
200 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
201}
202pub type ACPI_BUFFER = Struct_acpi_buffer;
203#[repr(C)]
204#[derive(Copy)]
205pub struct Struct_acpi_predefined_names {
206 pub Name: *mut i8,
207 pub Type: UINT8,
208 pub Val: *mut i8,
209}
210impl ::core::clone::Clone for Struct_acpi_predefined_names {
211 fn clone(&self) -> Self { *self }
212}
213impl ::core::default::Default for Struct_acpi_predefined_names {
214 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
215}
216pub type ACPI_PREDEFINED_NAMES = Struct_acpi_predefined_names;
217#[repr(C)]
218#[derive(Copy)]
219pub struct Struct_acpi_system_info {
220 pub AcpiCaVersion: UINT32,
221 pub Flags: UINT32,
222 pub TimerResolution: UINT32,
223 pub Reserved1: UINT32,
224 pub Reserved2: UINT32,
225 pub DebugLevel: UINT32,
226 pub DebugLayer: UINT32,
227}
228impl ::core::clone::Clone for Struct_acpi_system_info {
229 fn clone(&self) -> Self { *self }
230}
231impl ::core::default::Default for Struct_acpi_system_info {
232 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
233}
234pub type ACPI_SYSTEM_INFO = Struct_acpi_system_info;
235#[repr(C)]
236#[derive(Copy)]
237pub struct Struct_acpi_statistics {
238 pub SciCount: UINT32,
239 pub GpeCount: UINT32,
240 pub FixedEventCount: [UINT32; 5usize],
241 pub MethodCount: UINT32,
242}
243impl ::core::clone::Clone for Struct_acpi_statistics {
244 fn clone(&self) -> Self { *self }
245}
246impl ::core::default::Default for Struct_acpi_statistics {
247 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
248}
249pub type ACPI_STATISTICS = Struct_acpi_statistics;
250pub type ACPI_OSD_HANDLER =
251 ::core::option::Option<unsafe extern "C" fn(Context:
252 *mut c_void)
253 -> UINT32>;
254pub type ACPI_OSD_EXEC_CALLBACK =
255 ::core::option::Option<unsafe extern "C" fn(Context:
256 *mut c_void)>;
257pub type ACPI_SCI_HANDLER =
258 ::core::option::Option<unsafe extern "C" fn(Context:
259 *mut c_void)
260 -> UINT32>;
261pub type ACPI_GBL_EVENT_HANDLER =
262 ::core::option::Option<unsafe extern "C" fn(EventType: UINT32,
263 Device: ACPI_HANDLE,
264 EventNumber: UINT32,
265 Context:
266 *mut c_void)>;
267pub type ACPI_EVENT_HANDLER =
268 ::core::option::Option<unsafe extern "C" fn(Context:
269 *mut c_void)
270 -> UINT32>;
271pub type ACPI_GPE_HANDLER =
272 ::core::option::Option<unsafe extern "C" fn(GpeDevice: ACPI_HANDLE,
273 GpeNumber: UINT32,
274 Context:
275 *mut c_void)
276 -> UINT32>;
277pub type ACPI_NOTIFY_HANDLER =
278 ::core::option::Option<unsafe extern "C" fn(Device: ACPI_HANDLE,
279 Value: UINT32,
280 Context:
281 *mut c_void)>;
282pub type ACPI_OBJECT_HANDLER =
283 ::core::option::Option<unsafe extern "C" fn(Object: ACPI_HANDLE,
284 Data:
285 *mut c_void)>;
286pub type ACPI_INIT_HANDLER =
287 ::core::option::Option<extern "C" fn(Object: ACPI_HANDLE, Function: UINT32)
288 -> ACPI_STATUS>;
289pub type ACPI_EXCEPTION_HANDLER =
290 ::core::option::Option<unsafe extern "C" fn(AmlStatus: ACPI_STATUS,
291 Name: ACPI_NAME,
292 Opcode: UINT16,
293 AmlOffset: UINT32,
294 Context:
295 *mut c_void)
296 -> ACPI_STATUS>;
297pub type ACPI_TABLE_HANDLER =
298 ::core::option::Option<unsafe extern "C" fn(Event: UINT32,
299 Table:
300 *mut c_void,
301 Context:
302 *mut c_void)
303 -> ACPI_STATUS>;
304pub type ACPI_ADR_SPACE_HANDLER =
305 ::core::option::Option<unsafe extern "C" fn(Function: UINT32,
306 Address: ACPI_PHYSICAL_ADDRESS,
307 BitWidth: UINT32,
308 Value: *mut UINT64,
309 HandlerContext:
310 *mut c_void,
311 RegionContext:
312 *mut c_void)
313 -> ACPI_STATUS>;
314#[repr(C)]
315#[derive(Copy)]
316pub struct Struct_acpi_connection_info {
317 pub Connection: *mut UINT8,
318 pub Length: UINT16,
319 pub AccessLength: UINT8,
320}
321impl ::core::clone::Clone for Struct_acpi_connection_info {
322 fn clone(&self) -> Self { *self }
323}
324impl ::core::default::Default for Struct_acpi_connection_info {
325 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
326}
327pub type ACPI_CONNECTION_INFO = Struct_acpi_connection_info;
328pub type ACPI_ADR_SPACE_SETUP =
329 ::core::option::Option<unsafe extern "C" fn(RegionHandle: ACPI_HANDLE,
330 Function: UINT32,
331 HandlerContext:
332 *mut c_void,
333 RegionContext:
334 *mut *mut c_void)
335 -> ACPI_STATUS>;
336pub type ACPI_WALK_CALLBACK =
337 ::core::option::Option<unsafe extern "C" fn(Object: ACPI_HANDLE,
338 NestingLevel: UINT32,
339 Context:
340 *mut c_void,
341 ReturnValue:
342 *mut *mut c_void)
343 -> ACPI_STATUS>;
344pub type ACPI_INTERFACE_HANDLER =
345 ::core::option::Option<extern "C" fn(InterfaceName: ACPI_STRING,
346 Supported: UINT32) -> UINT32>;
347#[repr(C)]
348#[derive(Copy)]
349pub struct Struct_acpi_pnp_device_id {
350 pub Length: UINT32,
351 pub String: *mut i8,
352}
353impl ::core::clone::Clone for Struct_acpi_pnp_device_id {
354 fn clone(&self) -> Self { *self }
355}
356impl ::core::default::Default for Struct_acpi_pnp_device_id {
357 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
358}
359pub type ACPI_PNP_DEVICE_ID = Struct_acpi_pnp_device_id;
360#[repr(C)]
361#[derive(Copy)]
362pub struct Struct_acpi_pnp_device_id_list {
363 pub Count: UINT32,
364 pub ListSize: UINT32,
365 pub Ids: [ACPI_PNP_DEVICE_ID; 1usize],
366}
367impl ::core::clone::Clone for Struct_acpi_pnp_device_id_list {
368 fn clone(&self) -> Self { *self }
369}
370impl ::core::default::Default for Struct_acpi_pnp_device_id_list {
371 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
372}
373pub type ACPI_PNP_DEVICE_ID_LIST = Struct_acpi_pnp_device_id_list;
374#[repr(C)]
375#[derive(Copy)]
376pub struct Struct_acpi_device_info {
377 pub InfoSize: UINT32,
378 pub Name: UINT32,
379 pub Type: ACPI_OBJECT_TYPE,
380 pub ParamCount: UINT8,
381 pub Valid: UINT16,
382 pub Flags: UINT8,
383 pub HighestDstates: [UINT8; 4usize],
384 pub LowestDstates: [UINT8; 5usize],
385 pub CurrentStatus: UINT32,
386 pub Address: UINT64,
387 pub HardwareId: ACPI_PNP_DEVICE_ID,
388 pub UniqueId: ACPI_PNP_DEVICE_ID,
389 pub ClassCode: ACPI_PNP_DEVICE_ID,
390 pub CompatibleIdList: ACPI_PNP_DEVICE_ID_LIST,
391}
392impl ::core::clone::Clone for Struct_acpi_device_info {
393 fn clone(&self) -> Self { *self }
394}
395impl ::core::default::Default for Struct_acpi_device_info {
396 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
397}
398pub type ACPI_DEVICE_INFO = Struct_acpi_device_info;
399#[repr(C)]
400#[derive(Copy)]
401pub struct Struct_acpi_pci_id {
402 pub Segment: UINT16,
403 pub Bus: UINT16,
404 pub Device: UINT16,
405 pub Function: UINT16,
406}
407impl ::core::clone::Clone for Struct_acpi_pci_id {
408 fn clone(&self) -> Self { *self }
409}
410impl ::core::default::Default for Struct_acpi_pci_id {
411 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
412}
413pub type ACPI_PCI_ID = Struct_acpi_pci_id;
414#[repr(C)]
415#[derive(Copy)]
416pub struct Struct_acpi_mem_space_context {
417 pub Length: UINT32,
418 pub Address: ACPI_PHYSICAL_ADDRESS,
419 pub MappedPhysicalAddress: ACPI_PHYSICAL_ADDRESS,
420 pub MappedLogicalAddress: *mut UINT8,
421 pub MappedLength: ACPI_SIZE,
422}
423impl ::core::clone::Clone for Struct_acpi_mem_space_context {
424 fn clone(&self) -> Self { *self }
425}
426impl ::core::default::Default for Struct_acpi_mem_space_context {
427 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
428}
429pub type ACPI_MEM_SPACE_CONTEXT = Struct_acpi_mem_space_context;
430#[repr(C)]
431#[derive(Copy)]
432pub struct Struct_acpi_memory_list {
433 pub ListName: *mut i8,
434 pub ListHead: *mut c_void,
435 pub ObjectSize: UINT16,
436 pub MaxDepth: UINT16,
437 pub CurrentDepth: UINT16,
438}
439impl ::core::clone::Clone for Struct_acpi_memory_list {
440 fn clone(&self) -> Self { *self }
441}
442impl ::core::default::Default for Struct_acpi_memory_list {
443 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
444}
445pub type ACPI_MEMORY_LIST = Struct_acpi_memory_list;
446#[derive(Clone, Copy)]
447#[repr(u32)]
448pub enum Enum_Unnamed8 {
449 ACPI_TRACE_AML_METHOD = 0,
450 ACPI_TRACE_AML_OPCODE = 1,
451 ACPI_TRACE_AML_REGION = 2,
452}
453pub type ACPI_TRACE_EVENT_TYPE = Enum_Unnamed8;
454#[repr(C)]
455#[derive(Copy)]
456pub struct Struct_acpi_exception_info {
457 pub Name: *mut i8,
458}
459impl ::core::clone::Clone for Struct_acpi_exception_info {
460 fn clone(&self) -> Self { *self }
461}
462impl ::core::default::Default for Struct_acpi_exception_info {
463 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
464}
465pub type ACPI_EXCEPTION_INFO = Struct_acpi_exception_info;
466#[repr(C)]
467#[derive(Copy)]
468pub struct Struct_acpi_table_header {
469 pub Signature: [i8; 4usize],
470 pub Length: UINT32,
471 pub Revision: UINT8,
472 pub Checksum: UINT8,
473 pub OemId: [i8; 6usize],
474 pub OemTableId: [i8; 8usize],
475 pub OemRevision: UINT32,
476 pub AslCompilerId: [i8; 4usize],
477 pub AslCompilerRevision: UINT32,
478}
479impl ::core::clone::Clone for Struct_acpi_table_header {
480 fn clone(&self) -> Self { *self }
481}
482impl ::core::default::Default for Struct_acpi_table_header {
483 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
484}
485pub type ACPI_TABLE_HEADER = Struct_acpi_table_header;
486#[repr(C)]
487#[derive(Copy)]
488pub struct Struct_acpi_generic_address {
489 pub SpaceId: UINT8,
490 pub BitWidth: UINT8,
491 pub BitOffset: UINT8,
492 pub AccessWidth: UINT8,
493 pub Address: UINT64,
494}
495impl ::core::clone::Clone for Struct_acpi_generic_address {
496 fn clone(&self) -> Self { *self }
497}
498impl ::core::default::Default for Struct_acpi_generic_address {
499 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
500}
501pub type ACPI_GENERIC_ADDRESS = Struct_acpi_generic_address;
502#[repr(C)]
503#[derive(Copy)]
504pub struct Struct_acpi_table_rsdp {
505 pub Signature: [i8; 8usize],
506 pub Checksum: UINT8,
507 pub OemId: [i8; 6usize],
508 pub Revision: UINT8,
509 pub RsdtPhysicalAddress: UINT32,
510 pub Length: UINT32,
511 pub XsdtPhysicalAddress: UINT64,
512 pub ExtendedChecksum: UINT8,
513 pub Reserved: [UINT8; 3usize],
514}
515impl ::core::clone::Clone for Struct_acpi_table_rsdp {
516 fn clone(&self) -> Self { *self }
517}
518impl ::core::default::Default for Struct_acpi_table_rsdp {
519 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
520}
521pub type ACPI_TABLE_RSDP = Struct_acpi_table_rsdp;
522#[repr(C)]
523#[derive(Copy)]
524pub struct Struct_acpi_rsdp_common {
525 pub Signature: [i8; 8usize],
526 pub Checksum: UINT8,
527 pub OemId: [i8; 6usize],
528 pub Revision: UINT8,
529 pub RsdtPhysicalAddress: UINT32,
530}
531impl ::core::clone::Clone for Struct_acpi_rsdp_common {
532 fn clone(&self) -> Self { *self }
533}
534impl ::core::default::Default for Struct_acpi_rsdp_common {
535 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
536}
537pub type ACPI_RSDP_COMMON = Struct_acpi_rsdp_common;
538#[repr(C)]
539#[derive(Copy)]
540pub struct Struct_acpi_rsdp_extension {
541 pub Length: UINT32,
542 pub XsdtPhysicalAddress: UINT64,
543 pub ExtendedChecksum: UINT8,
544 pub Reserved: [UINT8; 3usize],
545}
546impl ::core::clone::Clone for Struct_acpi_rsdp_extension {
547 fn clone(&self) -> Self { *self }
548}
549impl ::core::default::Default for Struct_acpi_rsdp_extension {
550 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
551}
552pub type ACPI_RSDP_EXTENSION = Struct_acpi_rsdp_extension;
553#[repr(C)]
554#[derive(Copy)]
555pub struct Struct_acpi_table_rsdt {
556 pub Header: ACPI_TABLE_HEADER,
557 pub TableOffsetEntry: [UINT32; 1usize],
558}
559impl ::core::clone::Clone for Struct_acpi_table_rsdt {
560 fn clone(&self) -> Self { *self }
561}
562impl ::core::default::Default for Struct_acpi_table_rsdt {
563 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
564}
565pub type ACPI_TABLE_RSDT = Struct_acpi_table_rsdt;
566#[repr(C)]
567#[derive(Copy)]
568pub struct Struct_acpi_table_xsdt {
569 pub Header: ACPI_TABLE_HEADER,
570 pub TableOffsetEntry: [UINT64; 1usize],
571}
572impl ::core::clone::Clone for Struct_acpi_table_xsdt {
573 fn clone(&self) -> Self { *self }
574}
575impl ::core::default::Default for Struct_acpi_table_xsdt {
576 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
577}
578pub type ACPI_TABLE_XSDT = Struct_acpi_table_xsdt;
579#[repr(C)]
580#[derive(Copy)]
581pub struct Struct_acpi_table_facs {
582 pub Signature: [i8; 4usize],
583 pub Length: UINT32,
584 pub HardwareSignature: UINT32,
585 pub FirmwareWakingVector: UINT32,
586 pub GlobalLock: UINT32,
587 pub Flags: UINT32,
588 pub XFirmwareWakingVector: UINT64,
589 pub Version: UINT8,
590 pub Reserved: [UINT8; 3usize],
591 pub OspmFlags: UINT32,
592 pub Reserved1: [UINT8; 24usize],
593}
594impl ::core::clone::Clone for Struct_acpi_table_facs {
595 fn clone(&self) -> Self { *self }
596}
597impl ::core::default::Default for Struct_acpi_table_facs {
598 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
599}
600pub type ACPI_TABLE_FACS = Struct_acpi_table_facs;
601#[repr(C)]
602#[derive(Copy)]
603pub struct Struct_acpi_table_fadt {
604 pub Header: ACPI_TABLE_HEADER,
605 pub Facs: UINT32,
606 pub Dsdt: UINT32,
607 pub Model: UINT8,
608 pub PreferredProfile: UINT8,
609 pub SciInterrupt: UINT16,
610 pub SmiCommand: UINT32,
611 pub AcpiEnable: UINT8,
612 pub AcpiDisable: UINT8,
613 pub S4BiosRequest: UINT8,
614 pub PstateControl: UINT8,
615 pub Pm1aEventBlock: UINT32,
616 pub Pm1bEventBlock: UINT32,
617 pub Pm1aControlBlock: UINT32,
618 pub Pm1bControlBlock: UINT32,
619 pub Pm2ControlBlock: UINT32,
620 pub PmTimerBlock: UINT32,
621 pub Gpe0Block: UINT32,
622 pub Gpe1Block: UINT32,
623 pub Pm1EventLength: UINT8,
624 pub Pm1ControlLength: UINT8,
625 pub Pm2ControlLength: UINT8,
626 pub PmTimerLength: UINT8,
627 pub Gpe0BlockLength: UINT8,
628 pub Gpe1BlockLength: UINT8,
629 pub Gpe1Base: UINT8,
630 pub CstControl: UINT8,
631 pub C2Latency: UINT16,
632 pub C3Latency: UINT16,
633 pub FlushSize: UINT16,
634 pub FlushStride: UINT16,
635 pub DutyOffset: UINT8,
636 pub DutyWidth: UINT8,
637 pub DayAlarm: UINT8,
638 pub MonthAlarm: UINT8,
639 pub Century: UINT8,
640 pub BootFlags: UINT16,
641 pub Reserved: UINT8,
642 pub Flags: UINT32,
643 pub ResetRegister: ACPI_GENERIC_ADDRESS,
644 pub ResetValue: UINT8,
645 pub ArmBootFlags: UINT16,
646 pub MinorRevision: UINT8,
647 pub XFacs: UINT64,
648 pub XDsdt: UINT64,
649 pub XPm1aEventBlock: ACPI_GENERIC_ADDRESS,
650 pub XPm1bEventBlock: ACPI_GENERIC_ADDRESS,
651 pub XPm1aControlBlock: ACPI_GENERIC_ADDRESS,
652 pub XPm1bControlBlock: ACPI_GENERIC_ADDRESS,
653 pub XPm2ControlBlock: ACPI_GENERIC_ADDRESS,
654 pub XPmTimerBlock: ACPI_GENERIC_ADDRESS,
655 pub XGpe0Block: ACPI_GENERIC_ADDRESS,
656 pub XGpe1Block: ACPI_GENERIC_ADDRESS,
657 pub SleepControl: ACPI_GENERIC_ADDRESS,
658 pub SleepStatus: ACPI_GENERIC_ADDRESS,
659 pub HypervisorId: UINT64,
660}
661impl ::core::clone::Clone for Struct_acpi_table_fadt {
662 fn clone(&self) -> Self { *self }
663}
664impl ::core::default::Default for Struct_acpi_table_fadt {
665 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
666}
667pub type ACPI_TABLE_FADT = Struct_acpi_table_fadt;
668#[derive(Clone, Copy)]
669#[repr(u32)]
670pub enum Enum_AcpiPreferredPmProfiles {
671 PM_UNSPECIFIED = 0,
672 PM_DESKTOP = 1,
673 PM_MOBILE = 2,
674 PM_WORKSTATION = 3,
675 PM_ENTERPRISE_SERVER = 4,
676 PM_SOHO_SERVER = 5,
677 PM_APPLIANCE_PC = 6,
678 PM_PERFORMANCE_SERVER = 7,
679 PM_TABLET = 8,
680}
681#[repr(C)]
682#[derive(Copy)]
683pub struct Union_acpi_name_union {
684 pub _bindgen_data_: [u32; 1usize],
685}
686impl Union_acpi_name_union {
687 pub unsafe fn Integer(&mut self) -> *mut UINT32 {
688 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
689 ::core::mem::transmute(raw.offset(0))
690 }
691 pub unsafe fn Ascii(&mut self) -> *mut [i8; 4usize] {
692 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
693 ::core::mem::transmute(raw.offset(0))
694 }
695}
696impl ::core::clone::Clone for Union_acpi_name_union {
697 fn clone(&self) -> Self { *self }
698}
699impl ::core::default::Default for Union_acpi_name_union {
700 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
701}
702pub type ACPI_NAME_UNION = Union_acpi_name_union;
703#[repr(C)]
704#[derive(Copy)]
705pub struct Struct_acpi_table_desc {
706 pub Address: ACPI_PHYSICAL_ADDRESS,
707 pub Pointer: *mut ACPI_TABLE_HEADER,
708 pub Length: UINT32,
709 pub Signature: ACPI_NAME_UNION,
710 pub OwnerId: ACPI_OWNER_ID,
711 pub Flags: UINT8,
712}
713impl ::core::clone::Clone for Struct_acpi_table_desc {
714 fn clone(&self) -> Self { *self }
715}
716impl ::core::default::Default for Struct_acpi_table_desc {
717 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
718}
719pub type ACPI_TABLE_DESC = Struct_acpi_table_desc;
720#[repr(C)]
721#[derive(Copy)]
722pub struct Struct_acpi_subtable_header {
723 pub Type: UINT8,
724 pub Length: UINT8,
725}
726impl ::core::clone::Clone for Struct_acpi_subtable_header {
727 fn clone(&self) -> Self { *self }
728}
729impl ::core::default::Default for Struct_acpi_subtable_header {
730 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
731}
732pub type ACPI_SUBTABLE_HEADER = Struct_acpi_subtable_header;
733#[repr(C)]
734#[derive(Copy)]
735pub struct Struct_acpi_whea_header {
736 pub Action: UINT8,
737 pub Instruction: UINT8,
738 pub Flags: UINT8,
739 pub Reserved: UINT8,
740 pub RegisterRegion: ACPI_GENERIC_ADDRESS,
741 pub Value: UINT64,
742 pub Mask: UINT64,
743}
744impl ::core::clone::Clone for Struct_acpi_whea_header {
745 fn clone(&self) -> Self { *self }
746}
747impl ::core::default::Default for Struct_acpi_whea_header {
748 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
749}
750pub type ACPI_WHEA_HEADER = Struct_acpi_whea_header;
751#[repr(C)]
752#[derive(Copy)]
753pub struct Struct_acpi_table_bert {
754 pub Header: ACPI_TABLE_HEADER,
755 pub RegionLength: UINT32,
756 pub Address: UINT64,
757}
758impl ::core::clone::Clone for Struct_acpi_table_bert {
759 fn clone(&self) -> Self { *self }
760}
761impl ::core::default::Default for Struct_acpi_table_bert {
762 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
763}
764pub type ACPI_TABLE_BERT = Struct_acpi_table_bert;
765#[repr(C)]
766#[derive(Copy)]
767pub struct Struct_acpi_bert_region {
768 pub BlockStatus: UINT32,
769 pub RawDataOffset: UINT32,
770 pub RawDataLength: UINT32,
771 pub DataLength: UINT32,
772 pub ErrorSeverity: UINT32,
773}
774impl ::core::clone::Clone for Struct_acpi_bert_region {
775 fn clone(&self) -> Self { *self }
776}
777impl ::core::default::Default for Struct_acpi_bert_region {
778 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
779}
780pub type ACPI_BERT_REGION = Struct_acpi_bert_region;
781#[derive(Clone, Copy)]
782#[repr(u32)]
783pub enum Enum_AcpiBertErrorSeverity {
784 ACPI_BERT_ERROR_CORRECTABLE = 0,
785 ACPI_BERT_ERROR_FATAL = 1,
786 ACPI_BERT_ERROR_CORRECTED = 2,
787 ACPI_BERT_ERROR_NONE = 3,
788 ACPI_BERT_ERROR_RESERVED = 4,
789}
790#[repr(C)]
791#[derive(Copy)]
792pub struct Struct_acpi_table_cpep {
793 pub Header: ACPI_TABLE_HEADER,
794 pub Reserved: UINT64,
795}
796impl ::core::clone::Clone for Struct_acpi_table_cpep {
797 fn clone(&self) -> Self { *self }
798}
799impl ::core::default::Default for Struct_acpi_table_cpep {
800 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
801}
802pub type ACPI_TABLE_CPEP = Struct_acpi_table_cpep;
803#[repr(C)]
804#[derive(Copy)]
805pub struct Struct_acpi_cpep_polling {
806 pub Header: ACPI_SUBTABLE_HEADER,
807 pub Id: UINT8,
808 pub Eid: UINT8,
809 pub Interval: UINT32,
810}
811impl ::core::clone::Clone for Struct_acpi_cpep_polling {
812 fn clone(&self) -> Self { *self }
813}
814impl ::core::default::Default for Struct_acpi_cpep_polling {
815 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
816}
817pub type ACPI_CPEP_POLLING = Struct_acpi_cpep_polling;
818#[repr(C)]
819#[derive(Copy)]
820pub struct Struct_acpi_table_ecdt {
821 pub Header: ACPI_TABLE_HEADER,
822 pub Control: ACPI_GENERIC_ADDRESS,
823 pub Data: ACPI_GENERIC_ADDRESS,
824 pub Uid: UINT32,
825 pub Gpe: UINT8,
826 pub Id: [UINT8; 1usize],
827}
828impl ::core::clone::Clone for Struct_acpi_table_ecdt {
829 fn clone(&self) -> Self { *self }
830}
831impl ::core::default::Default for Struct_acpi_table_ecdt {
832 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
833}
834pub type ACPI_TABLE_ECDT = Struct_acpi_table_ecdt;
835#[repr(C)]
836#[derive(Copy)]
837pub struct Struct_acpi_table_einj {
838 pub Header: ACPI_TABLE_HEADER,
839 pub HeaderLength: UINT32,
840 pub Flags: UINT8,
841 pub Reserved: [UINT8; 3usize],
842 pub Entries: UINT32,
843}
844impl ::core::clone::Clone for Struct_acpi_table_einj {
845 fn clone(&self) -> Self { *self }
846}
847impl ::core::default::Default for Struct_acpi_table_einj {
848 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
849}
850pub type ACPI_TABLE_EINJ = Struct_acpi_table_einj;
851#[repr(C)]
852#[derive(Copy)]
853pub struct Struct_acpi_einj_entry {
854 pub WheaHeader: ACPI_WHEA_HEADER,
855}
856impl ::core::clone::Clone for Struct_acpi_einj_entry {
857 fn clone(&self) -> Self { *self }
858}
859impl ::core::default::Default for Struct_acpi_einj_entry {
860 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
861}
862pub type ACPI_EINJ_ENTRY = Struct_acpi_einj_entry;
863#[derive(Clone, Copy)]
864#[repr(u32)]
865pub enum Enum_AcpiEinjActions {
866 ACPI_EINJ_BEGIN_OPERATION = 0,
867 ACPI_EINJ_GET_TRIGGER_TABLE = 1,
868 ACPI_EINJ_SET_ERROR_TYPE = 2,
869 ACPI_EINJ_GET_ERROR_TYPE = 3,
870 ACPI_EINJ_END_OPERATION = 4,
871 ACPI_EINJ_EXECUTE_OPERATION = 5,
872 ACPI_EINJ_CHECK_BUSY_STATUS = 6,
873 ACPI_EINJ_GET_COMMAND_STATUS = 7,
874 ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS = 8,
875 ACPI_EINJ_GET_EXECUTE_TIMINGS = 9,
876 ACPI_EINJ_ACTION_RESERVED = 10,
877 ACPI_EINJ_TRIGGER_ERROR = 255,
878}
879#[derive(Clone, Copy)]
880#[repr(u32)]
881pub enum Enum_AcpiEinjInstructions {
882 ACPI_EINJ_READ_REGISTER = 0,
883 ACPI_EINJ_READ_REGISTER_VALUE = 1,
884 ACPI_EINJ_WRITE_REGISTER = 2,
885 ACPI_EINJ_WRITE_REGISTER_VALUE = 3,
886 ACPI_EINJ_NOOP = 4,
887 ACPI_EINJ_FLUSH_CACHELINE = 5,
888 ACPI_EINJ_INSTRUCTION_RESERVED = 6,
889}
890#[repr(C)]
891#[derive(Copy)]
892pub struct Struct_acpi_einj_error_type_with_addr {
893 pub ErrorType: UINT32,
894 pub VendorStructOffset: UINT32,
895 pub Flags: UINT32,
896 pub ApicId: UINT32,
897 pub Address: UINT64,
898 pub Range: UINT64,
899 pub PcieId: UINT32,
900}
901impl ::core::clone::Clone for Struct_acpi_einj_error_type_with_addr {
902 fn clone(&self) -> Self { *self }
903}
904impl ::core::default::Default for Struct_acpi_einj_error_type_with_addr {
905 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
906}
907pub type ACPI_EINJ_ERROR_TYPE_WITH_ADDR =
908 Struct_acpi_einj_error_type_with_addr;
909#[repr(C)]
910#[derive(Copy)]
911pub struct Struct_acpi_einj_vendor {
912 pub Length: UINT32,
913 pub PcieId: UINT32,
914 pub VendorId: UINT16,
915 pub DeviceId: UINT16,
916 pub RevisionId: UINT8,
917 pub Reserved: [UINT8; 3usize],
918}
919impl ::core::clone::Clone for Struct_acpi_einj_vendor {
920 fn clone(&self) -> Self { *self }
921}
922impl ::core::default::Default for Struct_acpi_einj_vendor {
923 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
924}
925pub type ACPI_EINJ_VENDOR = Struct_acpi_einj_vendor;
926#[repr(C)]
927#[derive(Copy)]
928pub struct Struct_acpi_einj_trigger {
929 pub HeaderSize: UINT32,
930 pub Revision: UINT32,
931 pub TableSize: UINT32,
932 pub EntryCount: UINT32,
933}
934impl ::core::clone::Clone for Struct_acpi_einj_trigger {
935 fn clone(&self) -> Self { *self }
936}
937impl ::core::default::Default for Struct_acpi_einj_trigger {
938 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
939}
940pub type ACPI_EINJ_TRIGGER = Struct_acpi_einj_trigger;
941#[derive(Clone, Copy)]
942#[repr(u32)]
943pub enum Enum_AcpiEinjCommandStatus {
944 ACPI_EINJ_SUCCESS = 0,
945 ACPI_EINJ_FAILURE = 1,
946 ACPI_EINJ_INVALID_ACCESS = 2,
947 ACPI_EINJ_STATUS_RESERVED = 3,
948}
949#[repr(C)]
950#[derive(Copy)]
951pub struct Struct_acpi_table_erst {
952 pub Header: ACPI_TABLE_HEADER,
953 pub HeaderLength: UINT32,
954 pub Reserved: UINT32,
955 pub Entries: UINT32,
956}
957impl ::core::clone::Clone for Struct_acpi_table_erst {
958 fn clone(&self) -> Self { *self }
959}
960impl ::core::default::Default for Struct_acpi_table_erst {
961 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
962}
963pub type ACPI_TABLE_ERST = Struct_acpi_table_erst;
964#[repr(C)]
965#[derive(Copy)]
966pub struct Struct_acpi_erst_entry {
967 pub WheaHeader: ACPI_WHEA_HEADER,
968}
969impl ::core::clone::Clone for Struct_acpi_erst_entry {
970 fn clone(&self) -> Self { *self }
971}
972impl ::core::default::Default for Struct_acpi_erst_entry {
973 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
974}
975pub type ACPI_ERST_ENTRY = Struct_acpi_erst_entry;
976#[derive(Clone, Copy)]
977#[repr(u32)]
978pub enum Enum_AcpiErstActions {
979 ACPI_ERST_BEGIN_WRITE = 0,
980 ACPI_ERST_BEGIN_READ = 1,
981 ACPI_ERST_BEGIN_CLEAR = 2,
982 ACPI_ERST_END = 3,
983 ACPI_ERST_SET_RECORD_OFFSET = 4,
984 ACPI_ERST_EXECUTE_OPERATION = 5,
985 ACPI_ERST_CHECK_BUSY_STATUS = 6,
986 ACPI_ERST_GET_COMMAND_STATUS = 7,
987 ACPI_ERST_GET_RECORD_ID = 8,
988 ACPI_ERST_SET_RECORD_ID = 9,
989 ACPI_ERST_GET_RECORD_COUNT = 10,
990 ACPI_ERST_BEGIN_DUMMY_WRIITE = 11,
991 ACPI_ERST_NOT_USED = 12,
992 ACPI_ERST_GET_ERROR_RANGE = 13,
993 ACPI_ERST_GET_ERROR_LENGTH = 14,
994 ACPI_ERST_GET_ERROR_ATTRIBUTES = 15,
995 ACPI_ERST_EXECUTE_TIMINGS = 16,
996 ACPI_ERST_ACTION_RESERVED = 17,
997}
998#[derive(Clone, Copy)]
999#[repr(u32)]
1000pub enum Enum_AcpiErstInstructions {
1001 ACPI_ERST_READ_REGISTER = 0,
1002 ACPI_ERST_READ_REGISTER_VALUE = 1,
1003 ACPI_ERST_WRITE_REGISTER = 2,
1004 ACPI_ERST_WRITE_REGISTER_VALUE = 3,
1005 ACPI_ERST_NOOP = 4,
1006 ACPI_ERST_LOAD_VAR1 = 5,
1007 ACPI_ERST_LOAD_VAR2 = 6,
1008 ACPI_ERST_STORE_VAR1 = 7,
1009 ACPI_ERST_ADD = 8,
1010 ACPI_ERST_SUBTRACT = 9,
1011 ACPI_ERST_ADD_VALUE = 10,
1012 ACPI_ERST_SUBTRACT_VALUE = 11,
1013 ACPI_ERST_STALL = 12,
1014 ACPI_ERST_STALL_WHILE_TRUE = 13,
1015 ACPI_ERST_SKIP_NEXT_IF_TRUE = 14,
1016 ACPI_ERST_GOTO = 15,
1017 ACPI_ERST_SET_SRC_ADDRESS_BASE = 16,
1018 ACPI_ERST_SET_DST_ADDRESS_BASE = 17,
1019 ACPI_ERST_MOVE_DATA = 18,
1020 ACPI_ERST_INSTRUCTION_RESERVED = 19,
1021}
1022#[derive(Clone, Copy)]
1023#[repr(u32)]
1024pub enum Enum_AcpiErstCommandStatus {
1025 ACPI_ERST_SUCESS = 0,
1026 ACPI_ERST_NO_SPACE = 1,
1027 ACPI_ERST_NOT_AVAILABLE = 2,
1028 ACPI_ERST_FAILURE = 3,
1029 ACPI_ERST_RECORD_EMPTY = 4,
1030 ACPI_ERST_NOT_FOUND = 5,
1031 ACPI_ERST_STATUS_RESERVED = 6,
1032}
1033#[repr(C)]
1034#[derive(Copy)]
1035pub struct Struct_acpi_erst_info {
1036 pub Signature: UINT16,
1037 pub Data: [UINT8; 48usize],
1038}
1039impl ::core::clone::Clone for Struct_acpi_erst_info {
1040 fn clone(&self) -> Self { *self }
1041}
1042impl ::core::default::Default for Struct_acpi_erst_info {
1043 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1044}
1045pub type ACPI_ERST_INFO = Struct_acpi_erst_info;
1046#[repr(C)]
1047#[derive(Copy)]
1048pub struct Struct_acpi_table_hest {
1049 pub Header: ACPI_TABLE_HEADER,
1050 pub ErrorSourceCount: UINT32,
1051}
1052impl ::core::clone::Clone for Struct_acpi_table_hest {
1053 fn clone(&self) -> Self { *self }
1054}
1055impl ::core::default::Default for Struct_acpi_table_hest {
1056 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1057}
1058pub type ACPI_TABLE_HEST = Struct_acpi_table_hest;
1059#[repr(C)]
1060#[derive(Copy)]
1061pub struct Struct_acpi_hest_header {
1062 pub Type: UINT16,
1063 pub SourceId: UINT16,
1064}
1065impl ::core::clone::Clone for Struct_acpi_hest_header {
1066 fn clone(&self) -> Self { *self }
1067}
1068impl ::core::default::Default for Struct_acpi_hest_header {
1069 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1070}
1071pub type ACPI_HEST_HEADER = Struct_acpi_hest_header;
1072#[derive(Clone, Copy)]
1073#[repr(u32)]
1074pub enum Enum_AcpiHestTypes {
1075 ACPI_HEST_TYPE_IA32_CHECK = 0,
1076 ACPI_HEST_TYPE_IA32_CORRECTED_CHECK = 1,
1077 ACPI_HEST_TYPE_IA32_NMI = 2,
1078 ACPI_HEST_TYPE_NOT_USED3 = 3,
1079 ACPI_HEST_TYPE_NOT_USED4 = 4,
1080 ACPI_HEST_TYPE_NOT_USED5 = 5,
1081 ACPI_HEST_TYPE_AER_ROOT_PORT = 6,
1082 ACPI_HEST_TYPE_AER_ENDPOINT = 7,
1083 ACPI_HEST_TYPE_AER_BRIDGE = 8,
1084 ACPI_HEST_TYPE_GENERIC_ERROR = 9,
1085 ACPI_HEST_TYPE_GENERIC_ERROR_V2 = 10,
1086 ACPI_HEST_TYPE_RESERVED = 11,
1087}
1088#[repr(C)]
1089#[derive(Copy)]
1090pub struct Struct_acpi_hest_ia_error_bank {
1091 pub BankNumber: UINT8,
1092 pub ClearStatusOnInit: UINT8,
1093 pub StatusFormat: UINT8,
1094 pub Reserved: UINT8,
1095 pub ControlRegister: UINT32,
1096 pub ControlData: UINT64,
1097 pub StatusRegister: UINT32,
1098 pub AddressRegister: UINT32,
1099 pub MiscRegister: UINT32,
1100}
1101impl ::core::clone::Clone for Struct_acpi_hest_ia_error_bank {
1102 fn clone(&self) -> Self { *self }
1103}
1104impl ::core::default::Default for Struct_acpi_hest_ia_error_bank {
1105 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1106}
1107pub type ACPI_HEST_IA_ERROR_BANK = Struct_acpi_hest_ia_error_bank;
1108#[repr(C)]
1109#[derive(Copy)]
1110pub struct Struct_acpi_hest_aer_common {
1111 pub Reserved1: UINT16,
1112 pub Flags: UINT8,
1113 pub Enabled: UINT8,
1114 pub RecordsToPreallocate: UINT32,
1115 pub MaxSectionsPerRecord: UINT32,
1116 pub Bus: UINT32,
1117 pub Device: UINT16,
1118 pub Function: UINT16,
1119 pub DeviceControl: UINT16,
1120 pub Reserved2: UINT16,
1121 pub UncorrectableMask: UINT32,
1122 pub UncorrectableSeverity: UINT32,
1123 pub CorrectableMask: UINT32,
1124 pub AdvancedCapabilities: UINT32,
1125}
1126impl ::core::clone::Clone for Struct_acpi_hest_aer_common {
1127 fn clone(&self) -> Self { *self }
1128}
1129impl ::core::default::Default for Struct_acpi_hest_aer_common {
1130 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1131}
1132pub type ACPI_HEST_AER_COMMON = Struct_acpi_hest_aer_common;
1133#[repr(C)]
1134#[derive(Copy)]
1135pub struct Struct_acpi_hest_notify {
1136 pub Type: UINT8,
1137 pub Length: UINT8,
1138 pub ConfigWriteEnable: UINT16,
1139 pub PollInterval: UINT32,
1140 pub Vector: UINT32,
1141 pub PollingThresholdValue: UINT32,
1142 pub PollingThresholdWindow: UINT32,
1143 pub ErrorThresholdValue: UINT32,
1144 pub ErrorThresholdWindow: UINT32,
1145}
1146impl ::core::clone::Clone for Struct_acpi_hest_notify {
1147 fn clone(&self) -> Self { *self }
1148}
1149impl ::core::default::Default for Struct_acpi_hest_notify {
1150 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1151}
1152pub type ACPI_HEST_NOTIFY = Struct_acpi_hest_notify;
1153#[derive(Clone, Copy)]
1154#[repr(u32)]
1155pub enum Enum_AcpiHestNotifyTypes {
1156 ACPI_HEST_NOTIFY_POLLED = 0,
1157 ACPI_HEST_NOTIFY_EXTERNAL = 1,
1158 ACPI_HEST_NOTIFY_LOCAL = 2,
1159 ACPI_HEST_NOTIFY_SCI = 3,
1160 ACPI_HEST_NOTIFY_NMI = 4,
1161 ACPI_HEST_NOTIFY_CMCI = 5,
1162 ACPI_HEST_NOTIFY_MCE = 6,
1163 ACPI_HEST_NOTIFY_RESERVED = 7,
1164}
1165#[repr(C)]
1166#[derive(Copy)]
1167pub struct Struct_acpi_hest_ia_machine_check {
1168 pub Header: ACPI_HEST_HEADER,
1169 pub Reserved1: UINT16,
1170 pub Flags: UINT8,
1171 pub Enabled: UINT8,
1172 pub RecordsToPreallocate: UINT32,
1173 pub MaxSectionsPerRecord: UINT32,
1174 pub GlobalCapabilityData: UINT64,
1175 pub GlobalControlData: UINT64,
1176 pub NumHardwareBanks: UINT8,
1177 pub Reserved3: [UINT8; 7usize],
1178}
1179impl ::core::clone::Clone for Struct_acpi_hest_ia_machine_check {
1180 fn clone(&self) -> Self { *self }
1181}
1182impl ::core::default::Default for Struct_acpi_hest_ia_machine_check {
1183 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1184}
1185pub type ACPI_HEST_IA_MACHINE_CHECK = Struct_acpi_hest_ia_machine_check;
1186#[repr(C)]
1187#[derive(Copy)]
1188pub struct Struct_acpi_hest_ia_corrected {
1189 pub Header: ACPI_HEST_HEADER,
1190 pub Reserved1: UINT16,
1191 pub Flags: UINT8,
1192 pub Enabled: UINT8,
1193 pub RecordsToPreallocate: UINT32,
1194 pub MaxSectionsPerRecord: UINT32,
1195 pub Notify: ACPI_HEST_NOTIFY,
1196 pub NumHardwareBanks: UINT8,
1197 pub Reserved2: [UINT8; 3usize],
1198}
1199impl ::core::clone::Clone for Struct_acpi_hest_ia_corrected {
1200 fn clone(&self) -> Self { *self }
1201}
1202impl ::core::default::Default for Struct_acpi_hest_ia_corrected {
1203 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1204}
1205pub type ACPI_HEST_IA_CORRECTED = Struct_acpi_hest_ia_corrected;
1206#[repr(C)]
1207#[derive(Copy)]
1208pub struct Struct_acpi_hest_ia_nmi {
1209 pub Header: ACPI_HEST_HEADER,
1210 pub Reserved: UINT32,
1211 pub RecordsToPreallocate: UINT32,
1212 pub MaxSectionsPerRecord: UINT32,
1213 pub MaxRawDataLength: UINT32,
1214}
1215impl ::core::clone::Clone for Struct_acpi_hest_ia_nmi {
1216 fn clone(&self) -> Self { *self }
1217}
1218impl ::core::default::Default for Struct_acpi_hest_ia_nmi {
1219 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1220}
1221pub type ACPI_HEST_IA_NMI = Struct_acpi_hest_ia_nmi;
1222#[repr(C)]
1223#[derive(Copy)]
1224pub struct Struct_acpi_hest_aer_root {
1225 pub Header: ACPI_HEST_HEADER,
1226 pub Aer: ACPI_HEST_AER_COMMON,
1227 pub RootErrorCommand: UINT32,
1228}
1229impl ::core::clone::Clone for Struct_acpi_hest_aer_root {
1230 fn clone(&self) -> Self { *self }
1231}
1232impl ::core::default::Default for Struct_acpi_hest_aer_root {
1233 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1234}
1235pub type ACPI_HEST_AER_ROOT = Struct_acpi_hest_aer_root;
1236#[repr(C)]
1237#[derive(Copy)]
1238pub struct Struct_acpi_hest_aer {
1239 pub Header: ACPI_HEST_HEADER,
1240 pub Aer: ACPI_HEST_AER_COMMON,
1241}
1242impl ::core::clone::Clone for Struct_acpi_hest_aer {
1243 fn clone(&self) -> Self { *self }
1244}
1245impl ::core::default::Default for Struct_acpi_hest_aer {
1246 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1247}
1248pub type ACPI_HEST_AER = Struct_acpi_hest_aer;
1249#[repr(C)]
1250#[derive(Copy)]
1251pub struct Struct_acpi_hest_aer_bridge {
1252 pub Header: ACPI_HEST_HEADER,
1253 pub Aer: ACPI_HEST_AER_COMMON,
1254 pub UncorrectableMask2: UINT32,
1255 pub UncorrectableSeverity2: UINT32,
1256 pub AdvancedCapabilities2: UINT32,
1257}
1258impl ::core::clone::Clone for Struct_acpi_hest_aer_bridge {
1259 fn clone(&self) -> Self { *self }
1260}
1261impl ::core::default::Default for Struct_acpi_hest_aer_bridge {
1262 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1263}
1264pub type ACPI_HEST_AER_BRIDGE = Struct_acpi_hest_aer_bridge;
1265#[repr(C)]
1266#[derive(Copy)]
1267pub struct Struct_acpi_hest_generic {
1268 pub Header: ACPI_HEST_HEADER,
1269 pub RelatedSourceId: UINT16,
1270 pub Reserved: UINT8,
1271 pub Enabled: UINT8,
1272 pub RecordsToPreallocate: UINT32,
1273 pub MaxSectionsPerRecord: UINT32,
1274 pub MaxRawDataLength: UINT32,
1275 pub ErrorStatusAddress: ACPI_GENERIC_ADDRESS,
1276 pub Notify: ACPI_HEST_NOTIFY,
1277 pub ErrorBlockLength: UINT32,
1278}
1279impl ::core::clone::Clone for Struct_acpi_hest_generic {
1280 fn clone(&self) -> Self { *self }
1281}
1282impl ::core::default::Default for Struct_acpi_hest_generic {
1283 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1284}
1285pub type ACPI_HEST_GENERIC = Struct_acpi_hest_generic;
1286#[repr(C)]
1287#[derive(Copy)]
1288pub struct Struct_acpi_hest_generic_v2 {
1289 pub Header: ACPI_HEST_HEADER,
1290 pub RelatedSourceId: UINT16,
1291 pub Reserved: UINT8,
1292 pub Enabled: UINT8,
1293 pub RecordsToPreallocate: UINT32,
1294 pub MaxSectionsPerRecord: UINT32,
1295 pub MaxRawDataLength: UINT32,
1296 pub ErrorStatusAddress: ACPI_GENERIC_ADDRESS,
1297 pub Notify: ACPI_HEST_NOTIFY,
1298 pub ErrorBlockLength: UINT32,
1299 pub ReadAckRegister: ACPI_GENERIC_ADDRESS,
1300 pub ReadAckPreserve: UINT64,
1301 pub ReadAckWrite: UINT64,
1302}
1303impl ::core::clone::Clone for Struct_acpi_hest_generic_v2 {
1304 fn clone(&self) -> Self { *self }
1305}
1306impl ::core::default::Default for Struct_acpi_hest_generic_v2 {
1307 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1308}
1309pub type ACPI_HEST_GENERIC_V2 = Struct_acpi_hest_generic_v2;
1310#[repr(C)]
1311#[derive(Copy)]
1312pub struct Struct_acpi_hest_generic_status {
1313 pub BlockStatus: UINT32,
1314 pub RawDataOffset: UINT32,
1315 pub RawDataLength: UINT32,
1316 pub DataLength: UINT32,
1317 pub ErrorSeverity: UINT32,
1318}
1319impl ::core::clone::Clone for Struct_acpi_hest_generic_status {
1320 fn clone(&self) -> Self { *self }
1321}
1322impl ::core::default::Default for Struct_acpi_hest_generic_status {
1323 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1324}
1325pub type ACPI_HEST_GENERIC_STATUS = Struct_acpi_hest_generic_status;
1326#[repr(C)]
1327#[derive(Copy)]
1328pub struct Struct_acpi_hest_generic_data {
1329 pub SectionType: [UINT8; 16usize],
1330 pub ErrorSeverity: UINT32,
1331 pub Revision: UINT16,
1332 pub ValidationBits: UINT8,
1333 pub Flags: UINT8,
1334 pub ErrorDataLength: UINT32,
1335 pub FruId: [UINT8; 16usize],
1336 pub FruText: [UINT8; 20usize],
1337 pub TimeStamp: UINT64,
1338}
1339impl ::core::clone::Clone for Struct_acpi_hest_generic_data {
1340 fn clone(&self) -> Self { *self }
1341}
1342impl ::core::default::Default for Struct_acpi_hest_generic_data {
1343 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1344}
1345pub type ACPI_HEST_GENERIC_DATA = Struct_acpi_hest_generic_data;
1346#[repr(C)]
1347#[derive(Copy)]
1348pub struct Struct_acpi_table_madt {
1349 pub Header: ACPI_TABLE_HEADER,
1350 pub Address: UINT32,
1351 pub Flags: UINT32,
1352}
1353impl ::core::clone::Clone for Struct_acpi_table_madt {
1354 fn clone(&self) -> Self { *self }
1355}
1356impl ::core::default::Default for Struct_acpi_table_madt {
1357 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1358}
1359pub type ACPI_TABLE_MADT = Struct_acpi_table_madt;
1360#[derive(Clone, Copy)]
1361#[repr(u32)]
1362pub enum Enum_AcpiMadtType {
1363 ACPI_MADT_TYPE_LOCAL_APIC = 0,
1364 ACPI_MADT_TYPE_IO_APIC = 1,
1365 ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2,
1366 ACPI_MADT_TYPE_NMI_SOURCE = 3,
1367 ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4,
1368 ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5,
1369 ACPI_MADT_TYPE_IO_SAPIC = 6,
1370 ACPI_MADT_TYPE_LOCAL_SAPIC = 7,
1371 ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8,
1372 ACPI_MADT_TYPE_LOCAL_X2APIC = 9,
1373 ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10,
1374 ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11,
1375 ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12,
1376 ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13,
1377 ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14,
1378 ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15,
1379 ACPI_MADT_TYPE_RESERVED = 16,
1380}
1381#[repr(C)]
1382#[derive(Copy)]
1383pub struct Struct_acpi_madt_local_apic {
1384 pub Header: ACPI_SUBTABLE_HEADER,
1385 pub ProcessorId: UINT8,
1386 pub Id: UINT8,
1387 pub LapicFlags: UINT32,
1388}
1389impl ::core::clone::Clone for Struct_acpi_madt_local_apic {
1390 fn clone(&self) -> Self { *self }
1391}
1392impl ::core::default::Default for Struct_acpi_madt_local_apic {
1393 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1394}
1395pub type ACPI_MADT_LOCAL_APIC = Struct_acpi_madt_local_apic;
1396#[repr(C)]
1397#[derive(Copy)]
1398pub struct Struct_acpi_madt_io_apic {
1399 pub Header: ACPI_SUBTABLE_HEADER,
1400 pub Id: UINT8,
1401 pub Reserved: UINT8,
1402 pub Address: UINT32,
1403 pub GlobalIrqBase: UINT32,
1404}
1405impl ::core::clone::Clone for Struct_acpi_madt_io_apic {
1406 fn clone(&self) -> Self { *self }
1407}
1408impl ::core::default::Default for Struct_acpi_madt_io_apic {
1409 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1410}
1411pub type ACPI_MADT_IO_APIC = Struct_acpi_madt_io_apic;
1412#[repr(C)]
1413#[derive(Copy)]
1414pub struct Struct_acpi_madt_interrupt_override {
1415 pub Header: ACPI_SUBTABLE_HEADER,
1416 pub Bus: UINT8,
1417 pub SourceIrq: UINT8,
1418 pub GlobalIrq: UINT32,
1419 pub IntiFlags: UINT16,
1420}
1421impl ::core::clone::Clone for Struct_acpi_madt_interrupt_override {
1422 fn clone(&self) -> Self { *self }
1423}
1424impl ::core::default::Default for Struct_acpi_madt_interrupt_override {
1425 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1426}
1427pub type ACPI_MADT_INTERRUPT_OVERRIDE = Struct_acpi_madt_interrupt_override;
1428#[repr(C)]
1429#[derive(Copy)]
1430pub struct Struct_acpi_madt_nmi_source {
1431 pub Header: ACPI_SUBTABLE_HEADER,
1432 pub IntiFlags: UINT16,
1433 pub GlobalIrq: UINT32,
1434}
1435impl ::core::clone::Clone for Struct_acpi_madt_nmi_source {
1436 fn clone(&self) -> Self { *self }
1437}
1438impl ::core::default::Default for Struct_acpi_madt_nmi_source {
1439 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1440}
1441pub type ACPI_MADT_NMI_SOURCE = Struct_acpi_madt_nmi_source;
1442#[repr(C)]
1443#[derive(Copy)]
1444pub struct Struct_acpi_madt_local_apic_nmi {
1445 pub Header: ACPI_SUBTABLE_HEADER,
1446 pub ProcessorId: UINT8,
1447 pub IntiFlags: UINT16,
1448 pub Lint: UINT8,
1449}
1450impl ::core::clone::Clone for Struct_acpi_madt_local_apic_nmi {
1451 fn clone(&self) -> Self { *self }
1452}
1453impl ::core::default::Default for Struct_acpi_madt_local_apic_nmi {
1454 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1455}
1456pub type ACPI_MADT_LOCAL_APIC_NMI = Struct_acpi_madt_local_apic_nmi;
1457#[repr(C)]
1458#[derive(Copy)]
1459pub struct Struct_acpi_madt_local_apic_override {
1460 pub Header: ACPI_SUBTABLE_HEADER,
1461 pub Reserved: UINT16,
1462 pub Address: UINT64,
1463}
1464impl ::core::clone::Clone for Struct_acpi_madt_local_apic_override {
1465 fn clone(&self) -> Self { *self }
1466}
1467impl ::core::default::Default for Struct_acpi_madt_local_apic_override {
1468 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1469}
1470pub type ACPI_MADT_LOCAL_APIC_OVERRIDE = Struct_acpi_madt_local_apic_override;
1471#[repr(C)]
1472#[derive(Copy)]
1473pub struct Struct_acpi_madt_io_sapic {
1474 pub Header: ACPI_SUBTABLE_HEADER,
1475 pub Id: UINT8,
1476 pub Reserved: UINT8,
1477 pub GlobalIrqBase: UINT32,
1478 pub Address: UINT64,
1479}
1480impl ::core::clone::Clone for Struct_acpi_madt_io_sapic {
1481 fn clone(&self) -> Self { *self }
1482}
1483impl ::core::default::Default for Struct_acpi_madt_io_sapic {
1484 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1485}
1486pub type ACPI_MADT_IO_SAPIC = Struct_acpi_madt_io_sapic;
1487#[repr(C)]
1488#[derive(Copy)]
1489pub struct Struct_acpi_madt_local_sapic {
1490 pub Header: ACPI_SUBTABLE_HEADER,
1491 pub ProcessorId: UINT8,
1492 pub Id: UINT8,
1493 pub Eid: UINT8,
1494 pub Reserved: [UINT8; 3usize],
1495 pub LapicFlags: UINT32,
1496 pub Uid: UINT32,
1497 pub UidString: [i8; 1usize],
1498}
1499impl ::core::clone::Clone for Struct_acpi_madt_local_sapic {
1500 fn clone(&self) -> Self { *self }
1501}
1502impl ::core::default::Default for Struct_acpi_madt_local_sapic {
1503 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1504}
1505pub type ACPI_MADT_LOCAL_SAPIC = Struct_acpi_madt_local_sapic;
1506#[repr(C)]
1507#[derive(Copy)]
1508pub struct Struct_acpi_madt_interrupt_source {
1509 pub Header: ACPI_SUBTABLE_HEADER,
1510 pub IntiFlags: UINT16,
1511 pub Type: UINT8,
1512 pub Id: UINT8,
1513 pub Eid: UINT8,
1514 pub IoSapicVector: UINT8,
1515 pub GlobalIrq: UINT32,
1516 pub Flags: UINT32,
1517}
1518impl ::core::clone::Clone for Struct_acpi_madt_interrupt_source {
1519 fn clone(&self) -> Self { *self }
1520}
1521impl ::core::default::Default for Struct_acpi_madt_interrupt_source {
1522 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1523}
1524pub type ACPI_MADT_INTERRUPT_SOURCE = Struct_acpi_madt_interrupt_source;
1525#[repr(C)]
1526#[derive(Copy)]
1527pub struct Struct_acpi_madt_local_x2apic {
1528 pub Header: ACPI_SUBTABLE_HEADER,
1529 pub Reserved: UINT16,
1530 pub LocalApicId: UINT32,
1531 pub LapicFlags: UINT32,
1532 pub Uid: UINT32,
1533}
1534impl ::core::clone::Clone for Struct_acpi_madt_local_x2apic {
1535 fn clone(&self) -> Self { *self }
1536}
1537impl ::core::default::Default for Struct_acpi_madt_local_x2apic {
1538 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1539}
1540pub type ACPI_MADT_LOCAL_X2APIC = Struct_acpi_madt_local_x2apic;
1541#[repr(C)]
1542#[derive(Copy)]
1543pub struct Struct_acpi_madt_local_x2apic_nmi {
1544 pub Header: ACPI_SUBTABLE_HEADER,
1545 pub IntiFlags: UINT16,
1546 pub Uid: UINT32,
1547 pub Lint: UINT8,
1548 pub Reserved: [UINT8; 3usize],
1549}
1550impl ::core::clone::Clone for Struct_acpi_madt_local_x2apic_nmi {
1551 fn clone(&self) -> Self { *self }
1552}
1553impl ::core::default::Default for Struct_acpi_madt_local_x2apic_nmi {
1554 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1555}
1556pub type ACPI_MADT_LOCAL_X2APIC_NMI = Struct_acpi_madt_local_x2apic_nmi;
1557#[repr(C)]
1558#[derive(Copy)]
1559pub struct Struct_acpi_madt_generic_interrupt {
1560 pub Header: ACPI_SUBTABLE_HEADER,
1561 pub Reserved: UINT16,
1562 pub CpuInterfaceNumber: UINT32,
1563 pub Uid: UINT32,
1564 pub Flags: UINT32,
1565 pub ParkingVersion: UINT32,
1566 pub PerformanceInterrupt: UINT32,
1567 pub ParkedAddress: UINT64,
1568 pub BaseAddress: UINT64,
1569 pub GicvBaseAddress: UINT64,
1570 pub GichBaseAddress: UINT64,
1571 pub VgicInterrupt: UINT32,
1572 pub GicrBaseAddress: UINT64,
1573 pub ArmMpidr: UINT64,
1574 pub EfficiencyClass: UINT8,
1575 pub Reserved2: [UINT8; 3usize],
1576}
1577impl ::core::clone::Clone for Struct_acpi_madt_generic_interrupt {
1578 fn clone(&self) -> Self { *self }
1579}
1580impl ::core::default::Default for Struct_acpi_madt_generic_interrupt {
1581 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1582}
1583pub type ACPI_MADT_GENERIC_INTERRUPT = Struct_acpi_madt_generic_interrupt;
1584#[repr(C)]
1585#[derive(Copy)]
1586pub struct Struct_acpi_madt_generic_distributor {
1587 pub Header: ACPI_SUBTABLE_HEADER,
1588 pub Reserved: UINT16,
1589 pub GicId: UINT32,
1590 pub BaseAddress: UINT64,
1591 pub GlobalIrqBase: UINT32,
1592 pub Version: UINT8,
1593 pub Reserved2: [UINT8; 3usize],
1594}
1595impl ::core::clone::Clone for Struct_acpi_madt_generic_distributor {
1596 fn clone(&self) -> Self { *self }
1597}
1598impl ::core::default::Default for Struct_acpi_madt_generic_distributor {
1599 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1600}
1601pub type ACPI_MADT_GENERIC_DISTRIBUTOR = Struct_acpi_madt_generic_distributor;
1602#[derive(Clone, Copy)]
1603#[repr(u32)]
1604pub enum Enum_AcpiMadtGicVersion {
1605 ACPI_MADT_GIC_VERSION_NONE = 0,
1606 ACPI_MADT_GIC_VERSION_V1 = 1,
1607 ACPI_MADT_GIC_VERSION_V2 = 2,
1608 ACPI_MADT_GIC_VERSION_V3 = 3,
1609 ACPI_MADT_GIC_VERSION_V4 = 4,
1610 ACPI_MADT_GIC_VERSION_RESERVED = 5,
1611}
1612#[repr(C)]
1613#[derive(Copy)]
1614pub struct Struct_acpi_madt_generic_msi_frame {
1615 pub Header: ACPI_SUBTABLE_HEADER,
1616 pub Reserved: UINT16,
1617 pub MsiFrameId: UINT32,
1618 pub BaseAddress: UINT64,
1619 pub Flags: UINT32,
1620 pub SpiCount: UINT16,
1621 pub SpiBase: UINT16,
1622}
1623impl ::core::clone::Clone for Struct_acpi_madt_generic_msi_frame {
1624 fn clone(&self) -> Self { *self }
1625}
1626impl ::core::default::Default for Struct_acpi_madt_generic_msi_frame {
1627 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1628}
1629pub type ACPI_MADT_GENERIC_MSI_FRAME = Struct_acpi_madt_generic_msi_frame;
1630#[repr(C)]
1631#[derive(Copy)]
1632pub struct Struct_acpi_madt_generic_redistributor {
1633 pub Header: ACPI_SUBTABLE_HEADER,
1634 pub Reserved: UINT16,
1635 pub BaseAddress: UINT64,
1636 pub Length: UINT32,
1637}
1638impl ::core::clone::Clone for Struct_acpi_madt_generic_redistributor {
1639 fn clone(&self) -> Self { *self }
1640}
1641impl ::core::default::Default for Struct_acpi_madt_generic_redistributor {
1642 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1643}
1644pub type ACPI_MADT_GENERIC_REDISTRIBUTOR =
1645 Struct_acpi_madt_generic_redistributor;
1646#[repr(C)]
1647#[derive(Copy)]
1648pub struct Struct_acpi_madt_generic_translator {
1649 pub Header: ACPI_SUBTABLE_HEADER,
1650 pub Reserved: UINT16,
1651 pub TranslationId: UINT32,
1652 pub BaseAddress: UINT64,
1653 pub Reserved2: UINT32,
1654}
1655impl ::core::clone::Clone for Struct_acpi_madt_generic_translator {
1656 fn clone(&self) -> Self { *self }
1657}
1658impl ::core::default::Default for Struct_acpi_madt_generic_translator {
1659 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1660}
1661pub type ACPI_MADT_GENERIC_TRANSLATOR = Struct_acpi_madt_generic_translator;
1662#[repr(C)]
1663#[derive(Copy)]
1664pub struct Struct_acpi_table_msct {
1665 pub Header: ACPI_TABLE_HEADER,
1666 pub ProximityOffset: UINT32,
1667 pub MaxProximityDomains: UINT32,
1668 pub MaxClockDomains: UINT32,
1669 pub MaxAddress: UINT64,
1670}
1671impl ::core::clone::Clone for Struct_acpi_table_msct {
1672 fn clone(&self) -> Self { *self }
1673}
1674impl ::core::default::Default for Struct_acpi_table_msct {
1675 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1676}
1677pub type ACPI_TABLE_MSCT = Struct_acpi_table_msct;
1678#[repr(C)]
1679#[derive(Copy)]
1680pub struct Struct_acpi_msct_proximity {
1681 pub Revision: UINT8,
1682 pub Length: UINT8,
1683 pub RangeStart: UINT32,
1684 pub RangeEnd: UINT32,
1685 pub ProcessorCapacity: UINT32,
1686 pub MemoryCapacity: UINT64,
1687}
1688impl ::core::clone::Clone for Struct_acpi_msct_proximity {
1689 fn clone(&self) -> Self { *self }
1690}
1691impl ::core::default::Default for Struct_acpi_msct_proximity {
1692 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1693}
1694pub type ACPI_MSCT_PROXIMITY = Struct_acpi_msct_proximity;
1695#[repr(C)]
1696#[derive(Copy)]
1697pub struct Struct_acpi_table_nfit {
1698 pub Header: ACPI_TABLE_HEADER,
1699 pub Reserved: UINT32,
1700}
1701impl ::core::clone::Clone for Struct_acpi_table_nfit {
1702 fn clone(&self) -> Self { *self }
1703}
1704impl ::core::default::Default for Struct_acpi_table_nfit {
1705 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1706}
1707pub type ACPI_TABLE_NFIT = Struct_acpi_table_nfit;
1708#[repr(C)]
1709#[derive(Copy)]
1710pub struct Struct_acpi_nfit_header {
1711 pub Type: UINT16,
1712 pub Length: UINT16,
1713}
1714impl ::core::clone::Clone for Struct_acpi_nfit_header {
1715 fn clone(&self) -> Self { *self }
1716}
1717impl ::core::default::Default for Struct_acpi_nfit_header {
1718 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1719}
1720pub type ACPI_NFIT_HEADER = Struct_acpi_nfit_header;
1721#[derive(Clone, Copy)]
1722#[repr(u32)]
1723pub enum Enum_AcpiNfitType {
1724 ACPI_NFIT_TYPE_SYSTEM_ADDRESS = 0,
1725 ACPI_NFIT_TYPE_MEMORY_MAP = 1,
1726 ACPI_NFIT_TYPE_INTERLEAVE = 2,
1727 ACPI_NFIT_TYPE_SMBIOS = 3,
1728 ACPI_NFIT_TYPE_CONTROL_REGION = 4,
1729 ACPI_NFIT_TYPE_DATA_REGION = 5,
1730 ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6,
1731 ACPI_NFIT_TYPE_RESERVED = 7,
1732}
1733#[repr(C)]
1734#[derive(Copy)]
1735pub struct Struct_acpi_nfit_system_address {
1736 pub Header: ACPI_NFIT_HEADER,
1737 pub RangeIndex: UINT16,
1738 pub Flags: UINT16,
1739 pub Reserved: UINT32,
1740 pub ProximityDomain: UINT32,
1741 pub RangeGuid: [UINT8; 16usize],
1742 pub Address: UINT64,
1743 pub Length: UINT64,
1744 pub MemoryMapping: UINT64,
1745}
1746impl ::core::clone::Clone for Struct_acpi_nfit_system_address {
1747 fn clone(&self) -> Self { *self }
1748}
1749impl ::core::default::Default for Struct_acpi_nfit_system_address {
1750 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1751}
1752pub type ACPI_NFIT_SYSTEM_ADDRESS = Struct_acpi_nfit_system_address;
1753#[repr(C)]
1754#[derive(Copy)]
1755pub struct Struct_acpi_nfit_memory_map {
1756 pub Header: ACPI_NFIT_HEADER,
1757 pub DeviceHandle: UINT32,
1758 pub PhysicalId: UINT16,
1759 pub RegionId: UINT16,
1760 pub RangeIndex: UINT16,
1761 pub RegionIndex: UINT16,
1762 pub RegionSize: UINT64,
1763 pub RegionOffset: UINT64,
1764 pub Address: UINT64,
1765 pub InterleaveIndex: UINT16,
1766 pub InterleaveWays: UINT16,
1767 pub Flags: UINT16,
1768 pub Reserved: UINT16,
1769}
1770impl ::core::clone::Clone for Struct_acpi_nfit_memory_map {
1771 fn clone(&self) -> Self { *self }
1772}
1773impl ::core::default::Default for Struct_acpi_nfit_memory_map {
1774 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1775}
1776pub type ACPI_NFIT_MEMORY_MAP = Struct_acpi_nfit_memory_map;
1777#[repr(C)]
1778#[derive(Copy)]
1779pub struct Struct_acpi_nfit_interleave {
1780 pub Header: ACPI_NFIT_HEADER,
1781 pub InterleaveIndex: UINT16,
1782 pub Reserved: UINT16,
1783 pub LineCount: UINT32,
1784 pub LineSize: UINT32,
1785 pub LineOffset: [UINT32; 1usize],
1786}
1787impl ::core::clone::Clone for Struct_acpi_nfit_interleave {
1788 fn clone(&self) -> Self { *self }
1789}
1790impl ::core::default::Default for Struct_acpi_nfit_interleave {
1791 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1792}
1793pub type ACPI_NFIT_INTERLEAVE = Struct_acpi_nfit_interleave;
1794#[repr(C)]
1795#[derive(Copy)]
1796pub struct Struct_acpi_nfit_smbios {
1797 pub Header: ACPI_NFIT_HEADER,
1798 pub Reserved: UINT32,
1799 pub Data: [UINT8; 1usize],
1800}
1801impl ::core::clone::Clone for Struct_acpi_nfit_smbios {
1802 fn clone(&self) -> Self { *self }
1803}
1804impl ::core::default::Default for Struct_acpi_nfit_smbios {
1805 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1806}
1807pub type ACPI_NFIT_SMBIOS = Struct_acpi_nfit_smbios;
1808#[repr(C)]
1809#[derive(Copy)]
1810pub struct Struct_acpi_nfit_control_region {
1811 pub Header: ACPI_NFIT_HEADER,
1812 pub RegionIndex: UINT16,
1813 pub VendorId: UINT16,
1814 pub DeviceId: UINT16,
1815 pub RevisionId: UINT16,
1816 pub SubsystemVendorId: UINT16,
1817 pub SubsystemDeviceId: UINT16,
1818 pub SubsystemRevisionId: UINT16,
1819 pub Reserved: [UINT8; 6usize],
1820 pub SerialNumber: UINT32,
1821 pub Code: UINT16,
1822 pub Windows: UINT16,
1823 pub WindowSize: UINT64,
1824 pub CommandOffset: UINT64,
1825 pub CommandSize: UINT64,
1826 pub StatusOffset: UINT64,
1827 pub StatusSize: UINT64,
1828 pub Flags: UINT16,
1829 pub Reserved1: [UINT8; 6usize],
1830}
1831impl ::core::clone::Clone for Struct_acpi_nfit_control_region {
1832 fn clone(&self) -> Self { *self }
1833}
1834impl ::core::default::Default for Struct_acpi_nfit_control_region {
1835 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1836}
1837pub type ACPI_NFIT_CONTROL_REGION = Struct_acpi_nfit_control_region;
1838#[repr(C)]
1839#[derive(Copy)]
1840pub struct Struct_acpi_nfit_data_region {
1841 pub Header: ACPI_NFIT_HEADER,
1842 pub RegionIndex: UINT16,
1843 pub Windows: UINT16,
1844 pub Offset: UINT64,
1845 pub Size: UINT64,
1846 pub Capacity: UINT64,
1847 pub StartAddress: UINT64,
1848}
1849impl ::core::clone::Clone for Struct_acpi_nfit_data_region {
1850 fn clone(&self) -> Self { *self }
1851}
1852impl ::core::default::Default for Struct_acpi_nfit_data_region {
1853 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1854}
1855pub type ACPI_NFIT_DATA_REGION = Struct_acpi_nfit_data_region;
1856#[repr(C)]
1857#[derive(Copy)]
1858pub struct Struct_acpi_nfit_flush_address {
1859 pub Header: ACPI_NFIT_HEADER,
1860 pub DeviceHandle: UINT32,
1861 pub HintCount: UINT16,
1862 pub Reserved: [UINT8; 6usize],
1863 pub HintAddress: [UINT64; 1usize],
1864}
1865impl ::core::clone::Clone for Struct_acpi_nfit_flush_address {
1866 fn clone(&self) -> Self { *self }
1867}
1868impl ::core::default::Default for Struct_acpi_nfit_flush_address {
1869 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1870}
1871pub type ACPI_NFIT_FLUSH_ADDRESS = Struct_acpi_nfit_flush_address;
1872#[repr(C)]
1873#[derive(Copy)]
1874pub struct Struct_acpi_table_sbst {
1875 pub Header: ACPI_TABLE_HEADER,
1876 pub WarningLevel: UINT32,
1877 pub LowLevel: UINT32,
1878 pub CriticalLevel: UINT32,
1879}
1880impl ::core::clone::Clone for Struct_acpi_table_sbst {
1881 fn clone(&self) -> Self { *self }
1882}
1883impl ::core::default::Default for Struct_acpi_table_sbst {
1884 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1885}
1886pub type ACPI_TABLE_SBST = Struct_acpi_table_sbst;
1887#[repr(C)]
1888#[derive(Copy)]
1889pub struct Struct_acpi_table_slit {
1890 pub Header: ACPI_TABLE_HEADER,
1891 pub LocalityCount: UINT64,
1892 pub Entry: [UINT8; 1usize],
1893}
1894impl ::core::clone::Clone for Struct_acpi_table_slit {
1895 fn clone(&self) -> Self { *self }
1896}
1897impl ::core::default::Default for Struct_acpi_table_slit {
1898 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1899}
1900pub type ACPI_TABLE_SLIT = Struct_acpi_table_slit;
1901#[repr(C)]
1902#[derive(Copy)]
1903pub struct Struct_acpi_table_srat {
1904 pub Header: ACPI_TABLE_HEADER,
1905 pub TableRevision: UINT32,
1906 pub Reserved: UINT64,
1907}
1908impl ::core::clone::Clone for Struct_acpi_table_srat {
1909 fn clone(&self) -> Self { *self }
1910}
1911impl ::core::default::Default for Struct_acpi_table_srat {
1912 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1913}
1914pub type ACPI_TABLE_SRAT = Struct_acpi_table_srat;
1915#[derive(Clone, Copy)]
1916#[repr(u32)]
1917pub enum Enum_AcpiSratType {
1918 ACPI_SRAT_TYPE_CPU_AFFINITY = 0,
1919 ACPI_SRAT_TYPE_MEMORY_AFFINITY = 1,
1920 ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY = 2,
1921 ACPI_SRAT_TYPE_GICC_AFFINITY = 3,
1922 ACPI_SRAT_TYPE_RESERVED = 4,
1923}
1924#[repr(C)]
1925#[derive(Copy)]
1926pub struct Struct_acpi_srat_cpu_affinity {
1927 pub Header: ACPI_SUBTABLE_HEADER,
1928 pub ProximityDomainLo: UINT8,
1929 pub ApicId: UINT8,
1930 pub Flags: UINT32,
1931 pub LocalSapicEid: UINT8,
1932 pub ProximityDomainHi: [UINT8; 3usize],
1933 pub ClockDomain: UINT32,
1934}
1935impl ::core::clone::Clone for Struct_acpi_srat_cpu_affinity {
1936 fn clone(&self) -> Self { *self }
1937}
1938impl ::core::default::Default for Struct_acpi_srat_cpu_affinity {
1939 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1940}
1941pub type ACPI_SRAT_CPU_AFFINITY = Struct_acpi_srat_cpu_affinity;
1942#[repr(C)]
1943#[derive(Copy)]
1944pub struct Struct_acpi_srat_mem_affinity {
1945 pub Header: ACPI_SUBTABLE_HEADER,
1946 pub ProximityDomain: UINT32,
1947 pub Reserved: UINT16,
1948 pub BaseAddress: UINT64,
1949 pub Length: UINT64,
1950 pub Reserved1: UINT32,
1951 pub Flags: UINT32,
1952 pub Reserved2: UINT64,
1953}
1954impl ::core::clone::Clone for Struct_acpi_srat_mem_affinity {
1955 fn clone(&self) -> Self { *self }
1956}
1957impl ::core::default::Default for Struct_acpi_srat_mem_affinity {
1958 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1959}
1960pub type ACPI_SRAT_MEM_AFFINITY = Struct_acpi_srat_mem_affinity;
1961#[repr(C)]
1962#[derive(Copy)]
1963pub struct Struct_acpi_srat_x2apic_cpu_affinity {
1964 pub Header: ACPI_SUBTABLE_HEADER,
1965 pub Reserved: UINT16,
1966 pub ProximityDomain: UINT32,
1967 pub ApicId: UINT32,
1968 pub Flags: UINT32,
1969 pub ClockDomain: UINT32,
1970 pub Reserved2: UINT32,
1971}
1972impl ::core::clone::Clone for Struct_acpi_srat_x2apic_cpu_affinity {
1973 fn clone(&self) -> Self { *self }
1974}
1975impl ::core::default::Default for Struct_acpi_srat_x2apic_cpu_affinity {
1976 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1977}
1978pub type ACPI_SRAT_X2APIC_CPU_AFFINITY = Struct_acpi_srat_x2apic_cpu_affinity;
1979#[repr(C)]
1980#[derive(Copy)]
1981pub struct Struct_acpi_srat_gicc_affinity {
1982 pub Header: ACPI_SUBTABLE_HEADER,
1983 pub ProximityDomain: UINT32,
1984 pub AcpiProcessorUid: UINT32,
1985 pub Flags: UINT32,
1986 pub ClockDomain: UINT32,
1987}
1988impl ::core::clone::Clone for Struct_acpi_srat_gicc_affinity {
1989 fn clone(&self) -> Self { *self }
1990}
1991impl ::core::default::Default for Struct_acpi_srat_gicc_affinity {
1992 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
1993}
1994pub type ACPI_SRAT_GICC_AFFINITY = Struct_acpi_srat_gicc_affinity;
1995#[repr(C)]
1996#[derive(Copy)]
1997pub struct Struct_acpi_table_asf {
1998 pub Header: ACPI_TABLE_HEADER,
1999}
2000impl ::core::clone::Clone for Struct_acpi_table_asf {
2001 fn clone(&self) -> Self { *self }
2002}
2003impl ::core::default::Default for Struct_acpi_table_asf {
2004 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2005}
2006pub type ACPI_TABLE_ASF = Struct_acpi_table_asf;
2007#[repr(C)]
2008#[derive(Copy)]
2009pub struct Struct_acpi_asf_header {
2010 pub Type: UINT8,
2011 pub Reserved: UINT8,
2012 pub Length: UINT16,
2013}
2014impl ::core::clone::Clone for Struct_acpi_asf_header {
2015 fn clone(&self) -> Self { *self }
2016}
2017impl ::core::default::Default for Struct_acpi_asf_header {
2018 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2019}
2020pub type ACPI_ASF_HEADER = Struct_acpi_asf_header;
2021#[derive(Clone, Copy)]
2022#[repr(u32)]
2023pub enum Enum_AcpiAsfType {
2024 ACPI_ASF_TYPE_INFO = 0,
2025 ACPI_ASF_TYPE_ALERT = 1,
2026 ACPI_ASF_TYPE_CONTROL = 2,
2027 ACPI_ASF_TYPE_BOOT = 3,
2028 ACPI_ASF_TYPE_ADDRESS = 4,
2029 ACPI_ASF_TYPE_RESERVED = 5,
2030}
2031#[repr(C)]
2032#[derive(Copy)]
2033pub struct Struct_acpi_asf_info {
2034 pub Header: ACPI_ASF_HEADER,
2035 pub MinResetValue: UINT8,
2036 pub MinPollInterval: UINT8,
2037 pub SystemId: UINT16,
2038 pub MfgId: UINT32,
2039 pub Flags: UINT8,
2040 pub Reserved2: [UINT8; 3usize],
2041}
2042impl ::core::clone::Clone for Struct_acpi_asf_info {
2043 fn clone(&self) -> Self { *self }
2044}
2045impl ::core::default::Default for Struct_acpi_asf_info {
2046 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2047}
2048pub type ACPI_ASF_INFO = Struct_acpi_asf_info;
2049#[repr(C)]
2050#[derive(Copy)]
2051pub struct Struct_acpi_asf_alert {
2052 pub Header: ACPI_ASF_HEADER,
2053 pub AssertMask: UINT8,
2054 pub DeassertMask: UINT8,
2055 pub Alerts: UINT8,
2056 pub DataLength: UINT8,
2057}
2058impl ::core::clone::Clone for Struct_acpi_asf_alert {
2059 fn clone(&self) -> Self { *self }
2060}
2061impl ::core::default::Default for Struct_acpi_asf_alert {
2062 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2063}
2064pub type ACPI_ASF_ALERT = Struct_acpi_asf_alert;
2065#[repr(C)]
2066#[derive(Copy)]
2067pub struct Struct_acpi_asf_alert_data {
2068 pub Address: UINT8,
2069 pub Command: UINT8,
2070 pub Mask: UINT8,
2071 pub Value: UINT8,
2072 pub SensorType: UINT8,
2073 pub Type: UINT8,
2074 pub Offset: UINT8,
2075 pub SourceType: UINT8,
2076 pub Severity: UINT8,
2077 pub SensorNumber: UINT8,
2078 pub Entity: UINT8,
2079 pub Instance: UINT8,
2080}
2081impl ::core::clone::Clone for Struct_acpi_asf_alert_data {
2082 fn clone(&self) -> Self { *self }
2083}
2084impl ::core::default::Default for Struct_acpi_asf_alert_data {
2085 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2086}
2087pub type ACPI_ASF_ALERT_DATA = Struct_acpi_asf_alert_data;
2088#[repr(C)]
2089#[derive(Copy)]
2090pub struct Struct_acpi_asf_remote {
2091 pub Header: ACPI_ASF_HEADER,
2092 pub Controls: UINT8,
2093 pub DataLength: UINT8,
2094 pub Reserved2: UINT16,
2095}
2096impl ::core::clone::Clone for Struct_acpi_asf_remote {
2097 fn clone(&self) -> Self { *self }
2098}
2099impl ::core::default::Default for Struct_acpi_asf_remote {
2100 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2101}
2102pub type ACPI_ASF_REMOTE = Struct_acpi_asf_remote;
2103#[repr(C)]
2104#[derive(Copy)]
2105pub struct Struct_acpi_asf_control_data {
2106 pub Function: UINT8,
2107 pub Address: UINT8,
2108 pub Command: UINT8,
2109 pub Value: UINT8,
2110}
2111impl ::core::clone::Clone for Struct_acpi_asf_control_data {
2112 fn clone(&self) -> Self { *self }
2113}
2114impl ::core::default::Default for Struct_acpi_asf_control_data {
2115 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2116}
2117pub type ACPI_ASF_CONTROL_DATA = Struct_acpi_asf_control_data;
2118#[repr(C)]
2119#[derive(Copy)]
2120pub struct Struct_acpi_asf_rmcp {
2121 pub Header: ACPI_ASF_HEADER,
2122 pub Capabilities: [UINT8; 7usize],
2123 pub CompletionCode: UINT8,
2124 pub EnterpriseId: UINT32,
2125 pub Command: UINT8,
2126 pub Parameter: UINT16,
2127 pub BootOptions: UINT16,
2128 pub OemParameters: UINT16,
2129}
2130impl ::core::clone::Clone for Struct_acpi_asf_rmcp {
2131 fn clone(&self) -> Self { *self }
2132}
2133impl ::core::default::Default for Struct_acpi_asf_rmcp {
2134 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2135}
2136pub type ACPI_ASF_RMCP = Struct_acpi_asf_rmcp;
2137#[repr(C)]
2138#[derive(Copy)]
2139pub struct Struct_acpi_asf_address {
2140 pub Header: ACPI_ASF_HEADER,
2141 pub EpromAddress: UINT8,
2142 pub Devices: UINT8,
2143}
2144impl ::core::clone::Clone for Struct_acpi_asf_address {
2145 fn clone(&self) -> Self { *self }
2146}
2147impl ::core::default::Default for Struct_acpi_asf_address {
2148 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2149}
2150pub type ACPI_ASF_ADDRESS = Struct_acpi_asf_address;
2151#[repr(C)]
2152#[derive(Copy)]
2153pub struct Struct_acpi_table_boot {
2154 pub Header: ACPI_TABLE_HEADER,
2155 pub CmosIndex: UINT8,
2156 pub Reserved: [UINT8; 3usize],
2157}
2158impl ::core::clone::Clone for Struct_acpi_table_boot {
2159 fn clone(&self) -> Self { *self }
2160}
2161impl ::core::default::Default for Struct_acpi_table_boot {
2162 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2163}
2164pub type ACPI_TABLE_BOOT = Struct_acpi_table_boot;
2165#[repr(C)]
2166#[derive(Copy)]
2167pub struct Struct_acpi_table_csrt {
2168 pub Header: ACPI_TABLE_HEADER,
2169}
2170impl ::core::clone::Clone for Struct_acpi_table_csrt {
2171 fn clone(&self) -> Self { *self }
2172}
2173impl ::core::default::Default for Struct_acpi_table_csrt {
2174 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2175}
2176pub type ACPI_TABLE_CSRT = Struct_acpi_table_csrt;
2177#[repr(C)]
2178#[derive(Copy)]
2179pub struct Struct_acpi_csrt_group {
2180 pub Length: UINT32,
2181 pub VendorId: UINT32,
2182 pub SubvendorId: UINT32,
2183 pub DeviceId: UINT16,
2184 pub SubdeviceId: UINT16,
2185 pub Revision: UINT16,
2186 pub Reserved: UINT16,
2187 pub SharedInfoLength: UINT32,
2188}
2189impl ::core::clone::Clone for Struct_acpi_csrt_group {
2190 fn clone(&self) -> Self { *self }
2191}
2192impl ::core::default::Default for Struct_acpi_csrt_group {
2193 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2194}
2195pub type ACPI_CSRT_GROUP = Struct_acpi_csrt_group;
2196#[repr(C)]
2197#[derive(Copy)]
2198pub struct Struct_acpi_csrt_shared_info {
2199 pub MajorVersion: UINT16,
2200 pub MinorVersion: UINT16,
2201 pub MmioBaseLow: UINT32,
2202 pub MmioBaseHigh: UINT32,
2203 pub GsiInterrupt: UINT32,
2204 pub InterruptPolarity: UINT8,
2205 pub InterruptMode: UINT8,
2206 pub NumChannels: UINT8,
2207 pub DmaAddressWidth: UINT8,
2208 pub BaseRequestLine: UINT16,
2209 pub NumHandshakeSignals: UINT16,
2210 pub MaxBlockSize: UINT32,
2211}
2212impl ::core::clone::Clone for Struct_acpi_csrt_shared_info {
2213 fn clone(&self) -> Self { *self }
2214}
2215impl ::core::default::Default for Struct_acpi_csrt_shared_info {
2216 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2217}
2218pub type ACPI_CSRT_SHARED_INFO = Struct_acpi_csrt_shared_info;
2219#[repr(C)]
2220#[derive(Copy)]
2221pub struct Struct_acpi_csrt_descriptor {
2222 pub Length: UINT32,
2223 pub Type: UINT16,
2224 pub Subtype: UINT16,
2225 pub Uid: UINT32,
2226}
2227impl ::core::clone::Clone for Struct_acpi_csrt_descriptor {
2228 fn clone(&self) -> Self { *self }
2229}
2230impl ::core::default::Default for Struct_acpi_csrt_descriptor {
2231 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2232}
2233pub type ACPI_CSRT_DESCRIPTOR = Struct_acpi_csrt_descriptor;
2234#[repr(C)]
2235#[derive(Copy)]
2236pub struct Struct_acpi_table_dbg2 {
2237 pub Header: ACPI_TABLE_HEADER,
2238 pub InfoOffset: UINT32,
2239 pub InfoCount: UINT32,
2240}
2241impl ::core::clone::Clone for Struct_acpi_table_dbg2 {
2242 fn clone(&self) -> Self { *self }
2243}
2244impl ::core::default::Default for Struct_acpi_table_dbg2 {
2245 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2246}
2247pub type ACPI_TABLE_DBG2 = Struct_acpi_table_dbg2;
2248#[repr(C)]
2249#[derive(Copy)]
2250pub struct Struct_acpi_dbg2_header {
2251 pub InfoOffset: UINT32,
2252 pub InfoCount: UINT32,
2253}
2254impl ::core::clone::Clone for Struct_acpi_dbg2_header {
2255 fn clone(&self) -> Self { *self }
2256}
2257impl ::core::default::Default for Struct_acpi_dbg2_header {
2258 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2259}
2260pub type ACPI_DBG2_HEADER = Struct_acpi_dbg2_header;
2261#[repr(C)]
2262#[derive(Copy)]
2263pub struct Struct_acpi_dbg2_device {
2264 pub Revision: UINT8,
2265 pub Length: UINT16,
2266 pub RegisterCount: UINT8,
2267 pub NamepathLength: UINT16,
2268 pub NamepathOffset: UINT16,
2269 pub OemDataLength: UINT16,
2270 pub OemDataOffset: UINT16,
2271 pub PortType: UINT16,
2272 pub PortSubtype: UINT16,
2273 pub Reserved: UINT16,
2274 pub BaseAddressOffset: UINT16,
2275 pub AddressSizeOffset: UINT16,
2276}
2277impl ::core::clone::Clone for Struct_acpi_dbg2_device {
2278 fn clone(&self) -> Self { *self }
2279}
2280impl ::core::default::Default for Struct_acpi_dbg2_device {
2281 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2282}
2283pub type ACPI_DBG2_DEVICE = Struct_acpi_dbg2_device;
2284#[repr(C)]
2285#[derive(Copy)]
2286pub struct Struct_acpi_table_dbgp {
2287 pub Header: ACPI_TABLE_HEADER,
2288 pub Type: UINT8,
2289 pub Reserved: [UINT8; 3usize],
2290 pub DebugPort: ACPI_GENERIC_ADDRESS,
2291}
2292impl ::core::clone::Clone for Struct_acpi_table_dbgp {
2293 fn clone(&self) -> Self { *self }
2294}
2295impl ::core::default::Default for Struct_acpi_table_dbgp {
2296 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2297}
2298pub type ACPI_TABLE_DBGP = Struct_acpi_table_dbgp;
2299#[repr(C)]
2300#[derive(Copy)]
2301pub struct Struct_acpi_table_dmar {
2302 pub Header: ACPI_TABLE_HEADER,
2303 pub Width: UINT8,
2304 pub Flags: UINT8,
2305 pub Reserved: [UINT8; 10usize],
2306}
2307impl ::core::clone::Clone for Struct_acpi_table_dmar {
2308 fn clone(&self) -> Self { *self }
2309}
2310impl ::core::default::Default for Struct_acpi_table_dmar {
2311 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2312}
2313pub type ACPI_TABLE_DMAR = Struct_acpi_table_dmar;
2314#[repr(C)]
2315#[derive(Copy)]
2316pub struct Struct_acpi_dmar_header {
2317 pub Type: UINT16,
2318 pub Length: UINT16,
2319}
2320impl ::core::clone::Clone for Struct_acpi_dmar_header {
2321 fn clone(&self) -> Self { *self }
2322}
2323impl ::core::default::Default for Struct_acpi_dmar_header {
2324 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2325}
2326pub type ACPI_DMAR_HEADER = Struct_acpi_dmar_header;
2327#[derive(Clone, Copy)]
2328#[repr(u32)]
2329pub enum Enum_AcpiDmarType {
2330 ACPI_DMAR_TYPE_HARDWARE_UNIT = 0,
2331 ACPI_DMAR_TYPE_RESERVED_MEMORY = 1,
2332 ACPI_DMAR_TYPE_ROOT_ATS = 2,
2333 ACPI_DMAR_TYPE_HARDWARE_AFFINITY = 3,
2334 ACPI_DMAR_TYPE_NAMESPACE = 4,
2335 ACPI_DMAR_TYPE_RESERVED = 5,
2336}
2337#[repr(C)]
2338#[derive(Copy)]
2339pub struct Struct_acpi_dmar_device_scope {
2340 pub EntryType: UINT8,
2341 pub Length: UINT8,
2342 pub Reserved: UINT16,
2343 pub EnumerationId: UINT8,
2344 pub Bus: UINT8,
2345}
2346impl ::core::clone::Clone for Struct_acpi_dmar_device_scope {
2347 fn clone(&self) -> Self { *self }
2348}
2349impl ::core::default::Default for Struct_acpi_dmar_device_scope {
2350 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2351}
2352pub type ACPI_DMAR_DEVICE_SCOPE = Struct_acpi_dmar_device_scope;
2353#[derive(Clone, Copy)]
2354#[repr(u32)]
2355pub enum Enum_AcpiDmarScopeType {
2356 ACPI_DMAR_SCOPE_TYPE_NOT_USED = 0,
2357 ACPI_DMAR_SCOPE_TYPE_ENDPOINT = 1,
2358 ACPI_DMAR_SCOPE_TYPE_BRIDGE = 2,
2359 ACPI_DMAR_SCOPE_TYPE_IOAPIC = 3,
2360 ACPI_DMAR_SCOPE_TYPE_HPET = 4,
2361 ACPI_DMAR_SCOPE_TYPE_NAMESPACE = 5,
2362 ACPI_DMAR_SCOPE_TYPE_RESERVED = 6,
2363}
2364#[repr(C)]
2365#[derive(Copy)]
2366pub struct Struct_acpi_dmar_pci_path {
2367 pub Device: UINT8,
2368 pub Function: UINT8,
2369}
2370impl ::core::clone::Clone for Struct_acpi_dmar_pci_path {
2371 fn clone(&self) -> Self { *self }
2372}
2373impl ::core::default::Default for Struct_acpi_dmar_pci_path {
2374 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2375}
2376pub type ACPI_DMAR_PCI_PATH = Struct_acpi_dmar_pci_path;
2377#[repr(C)]
2378#[derive(Copy)]
2379pub struct Struct_acpi_dmar_hardware_unit {
2380 pub Header: ACPI_DMAR_HEADER,
2381 pub Flags: UINT8,
2382 pub Reserved: UINT8,
2383 pub Segment: UINT16,
2384 pub Address: UINT64,
2385}
2386impl ::core::clone::Clone for Struct_acpi_dmar_hardware_unit {
2387 fn clone(&self) -> Self { *self }
2388}
2389impl ::core::default::Default for Struct_acpi_dmar_hardware_unit {
2390 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2391}
2392pub type ACPI_DMAR_HARDWARE_UNIT = Struct_acpi_dmar_hardware_unit;
2393#[repr(C)]
2394#[derive(Copy)]
2395pub struct Struct_acpi_dmar_reserved_memory {
2396 pub Header: ACPI_DMAR_HEADER,
2397 pub Reserved: UINT16,
2398 pub Segment: UINT16,
2399 pub BaseAddress: UINT64,
2400 pub EndAddress: UINT64,
2401}
2402impl ::core::clone::Clone for Struct_acpi_dmar_reserved_memory {
2403 fn clone(&self) -> Self { *self }
2404}
2405impl ::core::default::Default for Struct_acpi_dmar_reserved_memory {
2406 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2407}
2408pub type ACPI_DMAR_RESERVED_MEMORY = Struct_acpi_dmar_reserved_memory;
2409#[repr(C)]
2410#[derive(Copy)]
2411pub struct Struct_acpi_dmar_atsr {
2412 pub Header: ACPI_DMAR_HEADER,
2413 pub Flags: UINT8,
2414 pub Reserved: UINT8,
2415 pub Segment: UINT16,
2416}
2417impl ::core::clone::Clone for Struct_acpi_dmar_atsr {
2418 fn clone(&self) -> Self { *self }
2419}
2420impl ::core::default::Default for Struct_acpi_dmar_atsr {
2421 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2422}
2423pub type ACPI_DMAR_ATSR = Struct_acpi_dmar_atsr;
2424#[repr(C)]
2425#[derive(Copy)]
2426pub struct Struct_acpi_dmar_rhsa {
2427 pub Header: ACPI_DMAR_HEADER,
2428 pub Reserved: UINT32,
2429 pub BaseAddress: UINT64,
2430 pub ProximityDomain: UINT32,
2431}
2432impl ::core::clone::Clone for Struct_acpi_dmar_rhsa {
2433 fn clone(&self) -> Self { *self }
2434}
2435impl ::core::default::Default for Struct_acpi_dmar_rhsa {
2436 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2437}
2438pub type ACPI_DMAR_RHSA = Struct_acpi_dmar_rhsa;
2439#[repr(C)]
2440#[derive(Copy)]
2441pub struct Struct_acpi_dmar_andd {
2442 pub Header: ACPI_DMAR_HEADER,
2443 pub Reserved: [UINT8; 3usize],
2444 pub DeviceNumber: UINT8,
2445 pub DeviceName: [i8; 1usize],
2446}
2447impl ::core::clone::Clone for Struct_acpi_dmar_andd {
2448 fn clone(&self) -> Self { *self }
2449}
2450impl ::core::default::Default for Struct_acpi_dmar_andd {
2451 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2452}
2453pub type ACPI_DMAR_ANDD = Struct_acpi_dmar_andd;
2454#[repr(C)]
2455#[derive(Copy)]
2456pub struct Struct_acpi_table_hpet {
2457 pub Header: ACPI_TABLE_HEADER,
2458 pub Id: UINT32,
2459 pub Address: ACPI_GENERIC_ADDRESS,
2460 pub Sequence: UINT8,
2461 pub MinimumTick: UINT16,
2462 pub Flags: UINT8,
2463}
2464impl ::core::clone::Clone for Struct_acpi_table_hpet {
2465 fn clone(&self) -> Self { *self }
2466}
2467impl ::core::default::Default for Struct_acpi_table_hpet {
2468 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2469}
2470pub type ACPI_TABLE_HPET = Struct_acpi_table_hpet;
2471#[derive(Clone, Copy)]
2472#[repr(u32)]
2473pub enum Enum_AcpiHpetPageProtect {
2474 ACPI_HPET_NO_PAGE_PROTECT = 0,
2475 ACPI_HPET_PAGE_PROTECT4 = 1,
2476 ACPI_HPET_PAGE_PROTECT64 = 2,
2477}
2478#[repr(C)]
2479#[derive(Copy)]
2480pub struct Struct_acpi_table_ibft {
2481 pub Header: ACPI_TABLE_HEADER,
2482 pub Reserved: [UINT8; 12usize],
2483}
2484impl ::core::clone::Clone for Struct_acpi_table_ibft {
2485 fn clone(&self) -> Self { *self }
2486}
2487impl ::core::default::Default for Struct_acpi_table_ibft {
2488 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2489}
2490pub type ACPI_TABLE_IBFT = Struct_acpi_table_ibft;
2491#[repr(C)]
2492#[derive(Copy)]
2493pub struct Struct_acpi_ibft_header {
2494 pub Type: UINT8,
2495 pub Version: UINT8,
2496 pub Length: UINT16,
2497 pub Index: UINT8,
2498 pub Flags: UINT8,
2499}
2500impl ::core::clone::Clone for Struct_acpi_ibft_header {
2501 fn clone(&self) -> Self { *self }
2502}
2503impl ::core::default::Default for Struct_acpi_ibft_header {
2504 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2505}
2506pub type ACPI_IBFT_HEADER = Struct_acpi_ibft_header;
2507#[derive(Clone, Copy)]
2508#[repr(u32)]
2509pub enum Enum_AcpiIbftType {
2510 ACPI_IBFT_TYPE_NOT_USED = 0,
2511 ACPI_IBFT_TYPE_CONTROL = 1,
2512 ACPI_IBFT_TYPE_INITIATOR = 2,
2513 ACPI_IBFT_TYPE_NIC = 3,
2514 ACPI_IBFT_TYPE_TARGET = 4,
2515 ACPI_IBFT_TYPE_EXTENSIONS = 5,
2516 ACPI_IBFT_TYPE_RESERVED = 6,
2517}
2518#[repr(C)]
2519#[derive(Copy)]
2520pub struct Struct_acpi_ibft_control {
2521 pub Header: ACPI_IBFT_HEADER,
2522 pub Extensions: UINT16,
2523 pub InitiatorOffset: UINT16,
2524 pub Nic0Offset: UINT16,
2525 pub Target0Offset: UINT16,
2526 pub Nic1Offset: UINT16,
2527 pub Target1Offset: UINT16,
2528}
2529impl ::core::clone::Clone for Struct_acpi_ibft_control {
2530 fn clone(&self) -> Self { *self }
2531}
2532impl ::core::default::Default for Struct_acpi_ibft_control {
2533 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2534}
2535pub type ACPI_IBFT_CONTROL = Struct_acpi_ibft_control;
2536#[repr(C)]
2537#[derive(Copy)]
2538pub struct Struct_acpi_ibft_initiator {
2539 pub Header: ACPI_IBFT_HEADER,
2540 pub SnsServer: [UINT8; 16usize],
2541 pub SlpServer: [UINT8; 16usize],
2542 pub PrimaryServer: [UINT8; 16usize],
2543 pub SecondaryServer: [UINT8; 16usize],
2544 pub NameLength: UINT16,
2545 pub NameOffset: UINT16,
2546}
2547impl ::core::clone::Clone for Struct_acpi_ibft_initiator {
2548 fn clone(&self) -> Self { *self }
2549}
2550impl ::core::default::Default for Struct_acpi_ibft_initiator {
2551 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2552}
2553pub type ACPI_IBFT_INITIATOR = Struct_acpi_ibft_initiator;
2554#[repr(C)]
2555#[derive(Copy)]
2556pub struct Struct_acpi_ibft_nic {
2557 pub Header: ACPI_IBFT_HEADER,
2558 pub IpAddress: [UINT8; 16usize],
2559 pub SubnetMaskPrefix: UINT8,
2560 pub Origin: UINT8,
2561 pub Gateway: [UINT8; 16usize],
2562 pub PrimaryDns: [UINT8; 16usize],
2563 pub SecondaryDns: [UINT8; 16usize],
2564 pub Dhcp: [UINT8; 16usize],
2565 pub Vlan: UINT16,
2566 pub MacAddress: [UINT8; 6usize],
2567 pub PciAddress: UINT16,
2568 pub NameLength: UINT16,
2569 pub NameOffset: UINT16,
2570}
2571impl ::core::clone::Clone for Struct_acpi_ibft_nic {
2572 fn clone(&self) -> Self { *self }
2573}
2574impl ::core::default::Default for Struct_acpi_ibft_nic {
2575 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2576}
2577pub type ACPI_IBFT_NIC = Struct_acpi_ibft_nic;
2578#[repr(C)]
2579#[derive(Copy)]
2580pub struct Struct_acpi_ibft_target {
2581 pub Header: ACPI_IBFT_HEADER,
2582 pub TargetIpAddress: [UINT8; 16usize],
2583 pub TargetIpSocket: UINT16,
2584 pub TargetBootLun: [UINT8; 8usize],
2585 pub ChapType: UINT8,
2586 pub NicAssociation: UINT8,
2587 pub TargetNameLength: UINT16,
2588 pub TargetNameOffset: UINT16,
2589 pub ChapNameLength: UINT16,
2590 pub ChapNameOffset: UINT16,
2591 pub ChapSecretLength: UINT16,
2592 pub ChapSecretOffset: UINT16,
2593 pub ReverseChapNameLength: UINT16,
2594 pub ReverseChapNameOffset: UINT16,
2595 pub ReverseChapSecretLength: UINT16,
2596 pub ReverseChapSecretOffset: UINT16,
2597}
2598impl ::core::clone::Clone for Struct_acpi_ibft_target {
2599 fn clone(&self) -> Self { *self }
2600}
2601impl ::core::default::Default for Struct_acpi_ibft_target {
2602 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2603}
2604pub type ACPI_IBFT_TARGET = Struct_acpi_ibft_target;
2605#[repr(C)]
2606#[derive(Copy)]
2607pub struct Struct_acpi_table_iort {
2608 pub Header: ACPI_TABLE_HEADER,
2609 pub NodeCount: UINT32,
2610 pub NodeOffset: UINT32,
2611 pub Reserved: UINT32,
2612}
2613impl ::core::clone::Clone for Struct_acpi_table_iort {
2614 fn clone(&self) -> Self { *self }
2615}
2616impl ::core::default::Default for Struct_acpi_table_iort {
2617 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2618}
2619pub type ACPI_TABLE_IORT = Struct_acpi_table_iort;
2620#[repr(C)]
2621#[derive(Copy)]
2622pub struct Struct_acpi_iort_node {
2623 pub Type: UINT8,
2624 pub Length: UINT16,
2625 pub Revision: UINT8,
2626 pub Reserved: UINT32,
2627 pub MappingCount: UINT32,
2628 pub MappingOffset: UINT32,
2629 pub NodeData: [i8; 1usize],
2630}
2631impl ::core::clone::Clone for Struct_acpi_iort_node {
2632 fn clone(&self) -> Self { *self }
2633}
2634impl ::core::default::Default for Struct_acpi_iort_node {
2635 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2636}
2637pub type ACPI_IORT_NODE = Struct_acpi_iort_node;
2638#[derive(Clone, Copy)]
2639#[repr(u32)]
2640pub enum Enum_AcpiIortNodeType {
2641 ACPI_IORT_NODE_ITS_GROUP = 0,
2642 ACPI_IORT_NODE_NAMED_COMPONENT = 1,
2643 ACPI_IORT_NODE_PCI_ROOT_COMPLEX = 2,
2644 ACPI_IORT_NODE_SMMU = 3,
2645}
2646#[repr(C)]
2647#[derive(Copy)]
2648pub struct Struct_acpi_iort_id_mapping {
2649 pub InputBase: UINT32,
2650 pub IdCount: UINT32,
2651 pub OutputBase: UINT32,
2652 pub OutputReference: UINT32,
2653 pub Flags: UINT32,
2654}
2655impl ::core::clone::Clone for Struct_acpi_iort_id_mapping {
2656 fn clone(&self) -> Self { *self }
2657}
2658impl ::core::default::Default for Struct_acpi_iort_id_mapping {
2659 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2660}
2661pub type ACPI_IORT_ID_MAPPING = Struct_acpi_iort_id_mapping;
2662#[repr(C)]
2663#[derive(Copy)]
2664pub struct Struct_acpi_iort_memory_access {
2665 pub CacheCoherency: UINT32,
2666 pub Hints: UINT8,
2667 pub Reserved: UINT16,
2668 pub MemoryFlags: UINT8,
2669}
2670impl ::core::clone::Clone for Struct_acpi_iort_memory_access {
2671 fn clone(&self) -> Self { *self }
2672}
2673impl ::core::default::Default for Struct_acpi_iort_memory_access {
2674 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2675}
2676pub type ACPI_IORT_MEMORY_ACCESS = Struct_acpi_iort_memory_access;
2677#[repr(C)]
2678#[derive(Copy)]
2679pub struct Struct_acpi_iort_its_group {
2680 pub ItsCount: UINT32,
2681 pub Identifiers: [UINT32; 1usize],
2682}
2683impl ::core::clone::Clone for Struct_acpi_iort_its_group {
2684 fn clone(&self) -> Self { *self }
2685}
2686impl ::core::default::Default for Struct_acpi_iort_its_group {
2687 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2688}
2689pub type ACPI_IORT_ITS_GROUP = Struct_acpi_iort_its_group;
2690#[repr(C)]
2691#[derive(Copy)]
2692pub struct Struct_acpi_iort_named_component {
2693 pub NodeFlags: UINT32,
2694 pub MemoryProperties: UINT64,
2695 pub MemoryAddressLimit: UINT8,
2696 pub DeviceName: [i8; 1usize],
2697}
2698impl ::core::clone::Clone for Struct_acpi_iort_named_component {
2699 fn clone(&self) -> Self { *self }
2700}
2701impl ::core::default::Default for Struct_acpi_iort_named_component {
2702 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2703}
2704pub type ACPI_IORT_NAMED_COMPONENT = Struct_acpi_iort_named_component;
2705#[repr(C)]
2706#[derive(Copy)]
2707pub struct Struct_acpi_iort_root_complex {
2708 pub MemoryProperties: UINT64,
2709 pub AtsAttribute: UINT32,
2710 pub PciSegmentNumber: UINT32,
2711}
2712impl ::core::clone::Clone for Struct_acpi_iort_root_complex {
2713 fn clone(&self) -> Self { *self }
2714}
2715impl ::core::default::Default for Struct_acpi_iort_root_complex {
2716 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2717}
2718pub type ACPI_IORT_ROOT_COMPLEX = Struct_acpi_iort_root_complex;
2719#[repr(C)]
2720#[derive(Copy)]
2721pub struct Struct_acpi_iort_smmu {
2722 pub BaseAddress: UINT64,
2723 pub Span: UINT64,
2724 pub Model: UINT32,
2725 pub Flags: UINT32,
2726 pub GlobalInterruptOffset: UINT32,
2727 pub ContextInterruptCount: UINT32,
2728 pub ContextInterruptOffset: UINT32,
2729 pub PmuInterruptCount: UINT32,
2730 pub PmuInterruptOffset: UINT32,
2731 pub Interrupts: [UINT64; 1usize],
2732}
2733impl ::core::clone::Clone for Struct_acpi_iort_smmu {
2734 fn clone(&self) -> Self { *self }
2735}
2736impl ::core::default::Default for Struct_acpi_iort_smmu {
2737 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2738}
2739pub type ACPI_IORT_SMMU = Struct_acpi_iort_smmu;
2740#[repr(C)]
2741#[derive(Copy)]
2742pub struct Struct_acpi_table_ivrs {
2743 pub Header: ACPI_TABLE_HEADER,
2744 pub Info: UINT32,
2745 pub Reserved: UINT64,
2746}
2747impl ::core::clone::Clone for Struct_acpi_table_ivrs {
2748 fn clone(&self) -> Self { *self }
2749}
2750impl ::core::default::Default for Struct_acpi_table_ivrs {
2751 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2752}
2753pub type ACPI_TABLE_IVRS = Struct_acpi_table_ivrs;
2754#[repr(C)]
2755#[derive(Copy)]
2756pub struct Struct_acpi_ivrs_header {
2757 pub Type: UINT8,
2758 pub Flags: UINT8,
2759 pub Length: UINT16,
2760 pub DeviceId: UINT16,
2761}
2762impl ::core::clone::Clone for Struct_acpi_ivrs_header {
2763 fn clone(&self) -> Self { *self }
2764}
2765impl ::core::default::Default for Struct_acpi_ivrs_header {
2766 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2767}
2768pub type ACPI_IVRS_HEADER = Struct_acpi_ivrs_header;
2769#[derive(Clone, Copy)]
2770#[repr(u32)]
2771pub enum Enum_AcpiIvrsType {
2772 ACPI_IVRS_TYPE_HARDWARE = 16,
2773 ACPI_IVRS_TYPE_MEMORY1 = 32,
2774 ACPI_IVRS_TYPE_MEMORY2 = 33,
2775 ACPI_IVRS_TYPE_MEMORY3 = 34,
2776}
2777#[repr(C)]
2778#[derive(Copy)]
2779pub struct Struct_acpi_ivrs_hardware {
2780 pub Header: ACPI_IVRS_HEADER,
2781 pub CapabilityOffset: UINT16,
2782 pub BaseAddress: UINT64,
2783 pub PciSegmentGroup: UINT16,
2784 pub Info: UINT16,
2785 pub Reserved: UINT32,
2786}
2787impl ::core::clone::Clone for Struct_acpi_ivrs_hardware {
2788 fn clone(&self) -> Self { *self }
2789}
2790impl ::core::default::Default for Struct_acpi_ivrs_hardware {
2791 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2792}
2793pub type ACPI_IVRS_HARDWARE = Struct_acpi_ivrs_hardware;
2794#[repr(C)]
2795#[derive(Copy)]
2796pub struct Struct_acpi_ivrs_de_header {
2797 pub Type: UINT8,
2798 pub Id: UINT16,
2799 pub DataSetting: UINT8,
2800}
2801impl ::core::clone::Clone for Struct_acpi_ivrs_de_header {
2802 fn clone(&self) -> Self { *self }
2803}
2804impl ::core::default::Default for Struct_acpi_ivrs_de_header {
2805 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2806}
2807pub type ACPI_IVRS_DE_HEADER = Struct_acpi_ivrs_de_header;
2808#[derive(Clone, Copy)]
2809#[repr(u32)]
2810pub enum Enum_AcpiIvrsDeviceEntryType {
2811 ACPI_IVRS_TYPE_PAD4 = 0,
2812 ACPI_IVRS_TYPE_ALL = 1,
2813 ACPI_IVRS_TYPE_SELECT = 2,
2814 ACPI_IVRS_TYPE_START = 3,
2815 ACPI_IVRS_TYPE_END = 4,
2816 ACPI_IVRS_TYPE_PAD8 = 64,
2817 ACPI_IVRS_TYPE_NOT_USED = 65,
2818 ACPI_IVRS_TYPE_ALIAS_SELECT = 66,
2819 ACPI_IVRS_TYPE_ALIAS_START = 67,
2820 ACPI_IVRS_TYPE_EXT_SELECT = 70,
2821 ACPI_IVRS_TYPE_EXT_START = 71,
2822 ACPI_IVRS_TYPE_SPECIAL = 72,
2823}
2824#[repr(C)]
2825#[derive(Copy)]
2826pub struct Struct_acpi_ivrs_device4 {
2827 pub Header: ACPI_IVRS_DE_HEADER,
2828}
2829impl ::core::clone::Clone for Struct_acpi_ivrs_device4 {
2830 fn clone(&self) -> Self { *self }
2831}
2832impl ::core::default::Default for Struct_acpi_ivrs_device4 {
2833 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2834}
2835pub type ACPI_IVRS_DEVICE4 = Struct_acpi_ivrs_device4;
2836#[repr(C)]
2837#[derive(Copy)]
2838pub struct Struct_acpi_ivrs_device8a {
2839 pub Header: ACPI_IVRS_DE_HEADER,
2840 pub Reserved1: UINT8,
2841 pub UsedId: UINT16,
2842 pub Reserved2: UINT8,
2843}
2844impl ::core::clone::Clone for Struct_acpi_ivrs_device8a {
2845 fn clone(&self) -> Self { *self }
2846}
2847impl ::core::default::Default for Struct_acpi_ivrs_device8a {
2848 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2849}
2850pub type ACPI_IVRS_DEVICE8A = Struct_acpi_ivrs_device8a;
2851#[repr(C)]
2852#[derive(Copy)]
2853pub struct Struct_acpi_ivrs_device8b {
2854 pub Header: ACPI_IVRS_DE_HEADER,
2855 pub ExtendedData: UINT32,
2856}
2857impl ::core::clone::Clone for Struct_acpi_ivrs_device8b {
2858 fn clone(&self) -> Self { *self }
2859}
2860impl ::core::default::Default for Struct_acpi_ivrs_device8b {
2861 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2862}
2863pub type ACPI_IVRS_DEVICE8B = Struct_acpi_ivrs_device8b;
2864#[repr(C)]
2865#[derive(Copy)]
2866pub struct Struct_acpi_ivrs_device8c {
2867 pub Header: ACPI_IVRS_DE_HEADER,
2868 pub Handle: UINT8,
2869 pub UsedId: UINT16,
2870 pub Variety: UINT8,
2871}
2872impl ::core::clone::Clone for Struct_acpi_ivrs_device8c {
2873 fn clone(&self) -> Self { *self }
2874}
2875impl ::core::default::Default for Struct_acpi_ivrs_device8c {
2876 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2877}
2878pub type ACPI_IVRS_DEVICE8C = Struct_acpi_ivrs_device8c;
2879#[repr(C)]
2880#[derive(Copy)]
2881pub struct Struct_acpi_ivrs_memory {
2882 pub Header: ACPI_IVRS_HEADER,
2883 pub AuxData: UINT16,
2884 pub Reserved: UINT64,
2885 pub StartAddress: UINT64,
2886 pub MemoryLength: UINT64,
2887}
2888impl ::core::clone::Clone for Struct_acpi_ivrs_memory {
2889 fn clone(&self) -> Self { *self }
2890}
2891impl ::core::default::Default for Struct_acpi_ivrs_memory {
2892 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2893}
2894pub type ACPI_IVRS_MEMORY = Struct_acpi_ivrs_memory;
2895#[repr(C)]
2896#[derive(Copy)]
2897pub struct Struct_acpi_table_lpit {
2898 pub Header: ACPI_TABLE_HEADER,
2899}
2900impl ::core::clone::Clone for Struct_acpi_table_lpit {
2901 fn clone(&self) -> Self { *self }
2902}
2903impl ::core::default::Default for Struct_acpi_table_lpit {
2904 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2905}
2906pub type ACPI_TABLE_LPIT = Struct_acpi_table_lpit;
2907#[repr(C)]
2908#[derive(Copy)]
2909pub struct Struct_acpi_lpit_header {
2910 pub Type: UINT32,
2911 pub Length: UINT32,
2912 pub UniqueId: UINT16,
2913 pub Reserved: UINT16,
2914 pub Flags: UINT32,
2915}
2916impl ::core::clone::Clone for Struct_acpi_lpit_header {
2917 fn clone(&self) -> Self { *self }
2918}
2919impl ::core::default::Default for Struct_acpi_lpit_header {
2920 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2921}
2922pub type ACPI_LPIT_HEADER = Struct_acpi_lpit_header;
2923#[derive(Clone, Copy)]
2924#[repr(u32)]
2925pub enum Enum_AcpiLpitType {
2926 ACPI_LPIT_TYPE_NATIVE_CSTATE = 0,
2927 ACPI_LPIT_TYPE_RESERVED = 1,
2928}
2929#[repr(C)]
2930#[derive(Copy)]
2931pub struct Struct_acpi_lpit_native {
2932 pub Header: ACPI_LPIT_HEADER,
2933 pub EntryTrigger: ACPI_GENERIC_ADDRESS,
2934 pub Residency: UINT32,
2935 pub Latency: UINT32,
2936 pub ResidencyCounter: ACPI_GENERIC_ADDRESS,
2937 pub CounterFrequency: UINT64,
2938}
2939impl ::core::clone::Clone for Struct_acpi_lpit_native {
2940 fn clone(&self) -> Self { *self }
2941}
2942impl ::core::default::Default for Struct_acpi_lpit_native {
2943 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2944}
2945pub type ACPI_LPIT_NATIVE = Struct_acpi_lpit_native;
2946#[repr(C)]
2947#[derive(Copy)]
2948pub struct Struct_acpi_table_mcfg {
2949 pub Header: ACPI_TABLE_HEADER,
2950 pub Reserved: [UINT8; 8usize],
2951}
2952impl ::core::clone::Clone for Struct_acpi_table_mcfg {
2953 fn clone(&self) -> Self { *self }
2954}
2955impl ::core::default::Default for Struct_acpi_table_mcfg {
2956 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2957}
2958pub type ACPI_TABLE_MCFG = Struct_acpi_table_mcfg;
2959#[repr(C)]
2960#[derive(Copy)]
2961pub struct Struct_acpi_mcfg_allocation {
2962 pub Address: UINT64,
2963 pub PciSegment: UINT16,
2964 pub StartBusNumber: UINT8,
2965 pub EndBusNumber: UINT8,
2966 pub Reserved: UINT32,
2967}
2968impl ::core::clone::Clone for Struct_acpi_mcfg_allocation {
2969 fn clone(&self) -> Self { *self }
2970}
2971impl ::core::default::Default for Struct_acpi_mcfg_allocation {
2972 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2973}
2974pub type ACPI_MCFG_ALLOCATION = Struct_acpi_mcfg_allocation;
2975#[repr(C)]
2976#[derive(Copy)]
2977pub struct Struct_acpi_table_mchi {
2978 pub Header: ACPI_TABLE_HEADER,
2979 pub InterfaceType: UINT8,
2980 pub Protocol: UINT8,
2981 pub ProtocolData: UINT64,
2982 pub InterruptType: UINT8,
2983 pub Gpe: UINT8,
2984 pub PciDeviceFlag: UINT8,
2985 pub GlobalInterrupt: UINT32,
2986 pub ControlRegister: ACPI_GENERIC_ADDRESS,
2987 pub PciSegment: UINT8,
2988 pub PciBus: UINT8,
2989 pub PciDevice: UINT8,
2990 pub PciFunction: UINT8,
2991}
2992impl ::core::clone::Clone for Struct_acpi_table_mchi {
2993 fn clone(&self) -> Self { *self }
2994}
2995impl ::core::default::Default for Struct_acpi_table_mchi {
2996 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
2997}
2998pub type ACPI_TABLE_MCHI = Struct_acpi_table_mchi;
2999#[repr(C)]
3000#[derive(Copy)]
3001pub struct Struct_acpi_table_msdm {
3002 pub Header: ACPI_TABLE_HEADER,
3003}
3004impl ::core::clone::Clone for Struct_acpi_table_msdm {
3005 fn clone(&self) -> Self { *self }
3006}
3007impl ::core::default::Default for Struct_acpi_table_msdm {
3008 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3009}
3010pub type ACPI_TABLE_MSDM = Struct_acpi_table_msdm;
3011#[repr(C)]
3012#[derive(Copy)]
3013pub struct Struct_acpi_table_mtmr {
3014 pub Header: ACPI_TABLE_HEADER,
3015}
3016impl ::core::clone::Clone for Struct_acpi_table_mtmr {
3017 fn clone(&self) -> Self { *self }
3018}
3019impl ::core::default::Default for Struct_acpi_table_mtmr {
3020 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3021}
3022pub type ACPI_TABLE_MTMR = Struct_acpi_table_mtmr;
3023#[repr(C)]
3024#[derive(Copy)]
3025pub struct Struct_acpi_mtmr_entry {
3026 pub PhysicalAddress: ACPI_GENERIC_ADDRESS,
3027 pub Frequency: UINT32,
3028 pub Irq: UINT32,
3029}
3030impl ::core::clone::Clone for Struct_acpi_mtmr_entry {
3031 fn clone(&self) -> Self { *self }
3032}
3033impl ::core::default::Default for Struct_acpi_mtmr_entry {
3034 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3035}
3036pub type ACPI_MTMR_ENTRY = Struct_acpi_mtmr_entry;
3037#[repr(C)]
3038#[derive(Copy)]
3039pub struct Struct_acpi_table_slic {
3040 pub Header: ACPI_TABLE_HEADER,
3041}
3042impl ::core::clone::Clone for Struct_acpi_table_slic {
3043 fn clone(&self) -> Self { *self }
3044}
3045impl ::core::default::Default for Struct_acpi_table_slic {
3046 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3047}
3048pub type ACPI_TABLE_SLIC = Struct_acpi_table_slic;
3049#[repr(C)]
3050#[derive(Copy)]
3051pub struct Struct_acpi_table_spcr {
3052 pub Header: ACPI_TABLE_HEADER,
3053 pub InterfaceType: UINT8,
3054 pub Reserved: [UINT8; 3usize],
3055 pub SerialPort: ACPI_GENERIC_ADDRESS,
3056 pub InterruptType: UINT8,
3057 pub PcInterrupt: UINT8,
3058 pub Interrupt: UINT32,
3059 pub BaudRate: UINT8,
3060 pub Parity: UINT8,
3061 pub StopBits: UINT8,
3062 pub FlowControl: UINT8,
3063 pub TerminalType: UINT8,
3064 pub Reserved1: UINT8,
3065 pub PciDeviceId: UINT16,
3066 pub PciVendorId: UINT16,
3067 pub PciBus: UINT8,
3068 pub PciDevice: UINT8,
3069 pub PciFunction: UINT8,
3070 pub PciFlags: UINT32,
3071 pub PciSegment: UINT8,
3072 pub Reserved2: UINT32,
3073}
3074impl ::core::clone::Clone for Struct_acpi_table_spcr {
3075 fn clone(&self) -> Self { *self }
3076}
3077impl ::core::default::Default for Struct_acpi_table_spcr {
3078 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3079}
3080pub type ACPI_TABLE_SPCR = Struct_acpi_table_spcr;
3081#[repr(C)]
3082#[derive(Copy)]
3083pub struct Struct_acpi_table_spmi {
3084 pub Header: ACPI_TABLE_HEADER,
3085 pub InterfaceType: UINT8,
3086 pub Reserved: UINT8,
3087 pub SpecRevision: UINT16,
3088 pub InterruptType: UINT8,
3089 pub GpeNumber: UINT8,
3090 pub Reserved1: UINT8,
3091 pub PciDeviceFlag: UINT8,
3092 pub Interrupt: UINT32,
3093 pub IpmiRegister: ACPI_GENERIC_ADDRESS,
3094 pub PciSegment: UINT8,
3095 pub PciBus: UINT8,
3096 pub PciDevice: UINT8,
3097 pub PciFunction: UINT8,
3098 pub Reserved2: UINT8,
3099}
3100impl ::core::clone::Clone for Struct_acpi_table_spmi {
3101 fn clone(&self) -> Self { *self }
3102}
3103impl ::core::default::Default for Struct_acpi_table_spmi {
3104 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3105}
3106pub type ACPI_TABLE_SPMI = Struct_acpi_table_spmi;
3107#[derive(Clone, Copy)]
3108#[repr(u32)]
3109pub enum Enum_AcpiSpmiInterfaceTypes {
3110 ACPI_SPMI_NOT_USED = 0,
3111 ACPI_SPMI_KEYBOARD = 1,
3112 ACPI_SPMI_SMI = 2,
3113 ACPI_SPMI_BLOCK_TRANSFER = 3,
3114 ACPI_SPMI_SMBUS = 4,
3115 ACPI_SPMI_RESERVED = 5,
3116}
3117#[repr(C)]
3118#[derive(Copy)]
3119pub struct Struct_acpi_table_tcpa_hdr {
3120 pub Header: ACPI_TABLE_HEADER,
3121 pub PlatformClass: UINT16,
3122}
3123impl ::core::clone::Clone for Struct_acpi_table_tcpa_hdr {
3124 fn clone(&self) -> Self { *self }
3125}
3126impl ::core::default::Default for Struct_acpi_table_tcpa_hdr {
3127 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3128}
3129pub type ACPI_TABLE_TCPA_HDR = Struct_acpi_table_tcpa_hdr;
3130#[repr(C)]
3131#[derive(Copy)]
3132pub struct Struct_acpi_table_tcpa_client {
3133 pub MinimumLogLength: UINT32,
3134 pub LogAddress: UINT64,
3135}
3136impl ::core::clone::Clone for Struct_acpi_table_tcpa_client {
3137 fn clone(&self) -> Self { *self }
3138}
3139impl ::core::default::Default for Struct_acpi_table_tcpa_client {
3140 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3141}
3142pub type ACPI_TABLE_TCPA_CLIENT = Struct_acpi_table_tcpa_client;
3143#[repr(C)]
3144#[derive(Copy)]
3145pub struct Struct_acpi_table_tcpa_server {
3146 pub Reserved: UINT16,
3147 pub MinimumLogLength: UINT64,
3148 pub LogAddress: UINT64,
3149 pub SpecRevision: UINT16,
3150 pub DeviceFlags: UINT8,
3151 pub InterruptFlags: UINT8,
3152 pub GpeNumber: UINT8,
3153 pub Reserved2: [UINT8; 3usize],
3154 pub GlobalInterrupt: UINT32,
3155 pub Address: ACPI_GENERIC_ADDRESS,
3156 pub Reserved3: UINT32,
3157 pub ConfigAddress: ACPI_GENERIC_ADDRESS,
3158 pub Group: UINT8,
3159 pub Bus: UINT8,
3160 pub Device: UINT8,
3161 pub Function: UINT8,
3162}
3163impl ::core::clone::Clone for Struct_acpi_table_tcpa_server {
3164 fn clone(&self) -> Self { *self }
3165}
3166impl ::core::default::Default for Struct_acpi_table_tcpa_server {
3167 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3168}
3169pub type ACPI_TABLE_TCPA_SERVER = Struct_acpi_table_tcpa_server;
3170#[repr(C)]
3171#[derive(Copy)]
3172pub struct Struct_acpi_table_tpm2 {
3173 pub Header: ACPI_TABLE_HEADER,
3174 pub PlatformClass: UINT16,
3175 pub Reserved: UINT16,
3176 pub ControlAddress: UINT64,
3177 pub StartMethod: UINT32,
3178}
3179impl ::core::clone::Clone for Struct_acpi_table_tpm2 {
3180 fn clone(&self) -> Self { *self }
3181}
3182impl ::core::default::Default for Struct_acpi_table_tpm2 {
3183 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3184}
3185pub type ACPI_TABLE_TPM2 = Struct_acpi_table_tpm2;
3186#[repr(C)]
3187#[derive(Copy)]
3188pub struct Struct_acpi_table_uefi {
3189 pub Header: ACPI_TABLE_HEADER,
3190 pub Identifier: [UINT8; 16usize],
3191 pub DataOffset: UINT16,
3192}
3193impl ::core::clone::Clone for Struct_acpi_table_uefi {
3194 fn clone(&self) -> Self { *self }
3195}
3196impl ::core::default::Default for Struct_acpi_table_uefi {
3197 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3198}
3199pub type ACPI_TABLE_UEFI = Struct_acpi_table_uefi;
3200#[repr(C)]
3201#[derive(Copy)]
3202pub struct Struct_acpi_table_vrtc {
3203 pub Header: ACPI_TABLE_HEADER,
3204}
3205impl ::core::clone::Clone for Struct_acpi_table_vrtc {
3206 fn clone(&self) -> Self { *self }
3207}
3208impl ::core::default::Default for Struct_acpi_table_vrtc {
3209 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3210}
3211pub type ACPI_TABLE_VRTC = Struct_acpi_table_vrtc;
3212#[repr(C)]
3213#[derive(Copy)]
3214pub struct Struct_acpi_vrtc_entry {
3215 pub PhysicalAddress: ACPI_GENERIC_ADDRESS,
3216 pub Irq: UINT32,
3217}
3218impl ::core::clone::Clone for Struct_acpi_vrtc_entry {
3219 fn clone(&self) -> Self { *self }
3220}
3221impl ::core::default::Default for Struct_acpi_vrtc_entry {
3222 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3223}
3224pub type ACPI_VRTC_ENTRY = Struct_acpi_vrtc_entry;
3225#[repr(C)]
3226#[derive(Copy)]
3227pub struct Struct_acpi_table_waet {
3228 pub Header: ACPI_TABLE_HEADER,
3229 pub Flags: UINT32,
3230}
3231impl ::core::clone::Clone for Struct_acpi_table_waet {
3232 fn clone(&self) -> Self { *self }
3233}
3234impl ::core::default::Default for Struct_acpi_table_waet {
3235 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3236}
3237pub type ACPI_TABLE_WAET = Struct_acpi_table_waet;
3238#[repr(C)]
3239#[derive(Copy)]
3240pub struct Struct_acpi_table_wdat {
3241 pub Header: ACPI_TABLE_HEADER,
3242 pub HeaderLength: UINT32,
3243 pub PciSegment: UINT16,
3244 pub PciBus: UINT8,
3245 pub PciDevice: UINT8,
3246 pub PciFunction: UINT8,
3247 pub Reserved: [UINT8; 3usize],
3248 pub TimerPeriod: UINT32,
3249 pub MaxCount: UINT32,
3250 pub MinCount: UINT32,
3251 pub Flags: UINT8,
3252 pub Reserved2: [UINT8; 3usize],
3253 pub Entries: UINT32,
3254}
3255impl ::core::clone::Clone for Struct_acpi_table_wdat {
3256 fn clone(&self) -> Self { *self }
3257}
3258impl ::core::default::Default for Struct_acpi_table_wdat {
3259 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3260}
3261pub type ACPI_TABLE_WDAT = Struct_acpi_table_wdat;
3262#[repr(C)]
3263#[derive(Copy)]
3264pub struct Struct_acpi_wdat_entry {
3265 pub Action: UINT8,
3266 pub Instruction: UINT8,
3267 pub Reserved: UINT16,
3268 pub RegisterRegion: ACPI_GENERIC_ADDRESS,
3269 pub Value: UINT32,
3270 pub Mask: UINT32,
3271}
3272impl ::core::clone::Clone for Struct_acpi_wdat_entry {
3273 fn clone(&self) -> Self { *self }
3274}
3275impl ::core::default::Default for Struct_acpi_wdat_entry {
3276 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3277}
3278pub type ACPI_WDAT_ENTRY = Struct_acpi_wdat_entry;
3279#[derive(Clone, Copy)]
3280#[repr(u32)]
3281pub enum Enum_AcpiWdatActions {
3282 ACPI_WDAT_RESET = 1,
3283 ACPI_WDAT_GET_CURRENT_COUNTDOWN = 4,
3284 ACPI_WDAT_GET_COUNTDOWN = 5,
3285 ACPI_WDAT_SET_COUNTDOWN = 6,
3286 ACPI_WDAT_GET_RUNNING_STATE = 8,
3287 ACPI_WDAT_SET_RUNNING_STATE = 9,
3288 ACPI_WDAT_GET_STOPPED_STATE = 10,
3289 ACPI_WDAT_SET_STOPPED_STATE = 11,
3290 ACPI_WDAT_GET_REBOOT = 16,
3291 ACPI_WDAT_SET_REBOOT = 17,
3292 ACPI_WDAT_GET_SHUTDOWN = 18,
3293 ACPI_WDAT_SET_SHUTDOWN = 19,
3294 ACPI_WDAT_GET_STATUS = 32,
3295 ACPI_WDAT_SET_STATUS = 33,
3296 ACPI_WDAT_ACTION_RESERVED = 34,
3297}
3298#[derive(Clone, Copy)]
3299#[repr(u32)]
3300pub enum Enum_AcpiWdatInstructions {
3301 ACPI_WDAT_READ_VALUE = 0,
3302 ACPI_WDAT_READ_COUNTDOWN = 1,
3303 ACPI_WDAT_WRITE_VALUE = 2,
3304 ACPI_WDAT_WRITE_COUNTDOWN = 3,
3305 ACPI_WDAT_INSTRUCTION_RESERVED = 4,
3306 ACPI_WDAT_PRESERVE_REGISTER = 128,
3307}
3308#[repr(C)]
3309#[derive(Copy)]
3310pub struct Struct_acpi_table_wddt {
3311 pub Header: ACPI_TABLE_HEADER,
3312 pub SpecVersion: UINT16,
3313 pub TableVersion: UINT16,
3314 pub PciVendorId: UINT16,
3315 pub Address: ACPI_GENERIC_ADDRESS,
3316 pub MaxCount: UINT16,
3317 pub MinCount: UINT16,
3318 pub Period: UINT16,
3319 pub Status: UINT16,
3320 pub Capability: UINT16,
3321}
3322impl ::core::clone::Clone for Struct_acpi_table_wddt {
3323 fn clone(&self) -> Self { *self }
3324}
3325impl ::core::default::Default for Struct_acpi_table_wddt {
3326 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3327}
3328pub type ACPI_TABLE_WDDT = Struct_acpi_table_wddt;
3329#[repr(C)]
3330#[derive(Copy)]
3331pub struct Struct_acpi_table_wdrt {
3332 pub Header: ACPI_TABLE_HEADER,
3333 pub ControlRegister: ACPI_GENERIC_ADDRESS,
3334 pub CountRegister: ACPI_GENERIC_ADDRESS,
3335 pub PciDeviceId: UINT16,
3336 pub PciVendorId: UINT16,
3337 pub PciBus: UINT8,
3338 pub PciDevice: UINT8,
3339 pub PciFunction: UINT8,
3340 pub PciSegment: UINT8,
3341 pub MaxCount: UINT16,
3342 pub Units: UINT8,
3343}
3344impl ::core::clone::Clone for Struct_acpi_table_wdrt {
3345 fn clone(&self) -> Self { *self }
3346}
3347impl ::core::default::Default for Struct_acpi_table_wdrt {
3348 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3349}
3350pub type ACPI_TABLE_WDRT = Struct_acpi_table_wdrt;
3351#[repr(C)]
3352#[derive(Copy)]
3353pub struct Struct_acpi_table_bgrt {
3354 pub Header: ACPI_TABLE_HEADER,
3355 pub Version: UINT16,
3356 pub Status: UINT8,
3357 pub ImageType: UINT8,
3358 pub ImageAddress: UINT64,
3359 pub ImageOffsetX: UINT32,
3360 pub ImageOffsetY: UINT32,
3361}
3362impl ::core::clone::Clone for Struct_acpi_table_bgrt {
3363 fn clone(&self) -> Self { *self }
3364}
3365impl ::core::default::Default for Struct_acpi_table_bgrt {
3366 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3367}
3368pub type ACPI_TABLE_BGRT = Struct_acpi_table_bgrt;
3369#[repr(C)]
3370#[derive(Copy)]
3371pub struct Struct_acpi_table_drtm {
3372 pub Header: ACPI_TABLE_HEADER,
3373 pub EntryBaseAddress: UINT64,
3374 pub EntryLength: UINT64,
3375 pub EntryAddress32: UINT32,
3376 pub EntryAddress64: UINT64,
3377 pub ExitAddress: UINT64,
3378 pub LogAreaAddress: UINT64,
3379 pub LogAreaLength: UINT32,
3380 pub ArchDependentAddress: UINT64,
3381 pub Flags: UINT32,
3382}
3383impl ::core::clone::Clone for Struct_acpi_table_drtm {
3384 fn clone(&self) -> Self { *self }
3385}
3386impl ::core::default::Default for Struct_acpi_table_drtm {
3387 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3388}
3389pub type ACPI_TABLE_DRTM = Struct_acpi_table_drtm;
3390#[repr(C)]
3391#[derive(Copy)]
3392pub struct Struct_acpi_drtm_vtable_list {
3393 pub ValidatedTableCount: UINT32,
3394 pub ValidatedTables: [UINT64; 1usize],
3395}
3396impl ::core::clone::Clone for Struct_acpi_drtm_vtable_list {
3397 fn clone(&self) -> Self { *self }
3398}
3399impl ::core::default::Default for Struct_acpi_drtm_vtable_list {
3400 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3401}
3402pub type ACPI_DRTM_VTABLE_LIST = Struct_acpi_drtm_vtable_list;
3403#[repr(C)]
3404#[derive(Copy)]
3405pub struct Struct_acpi_drtm_resource {
3406 pub Size: [UINT8; 7usize],
3407 pub Type: UINT8,
3408 pub Address: UINT64,
3409}
3410impl ::core::clone::Clone for Struct_acpi_drtm_resource {
3411 fn clone(&self) -> Self { *self }
3412}
3413impl ::core::default::Default for Struct_acpi_drtm_resource {
3414 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3415}
3416pub type ACPI_DRTM_RESOURCE = Struct_acpi_drtm_resource;
3417#[repr(C)]
3418#[derive(Copy)]
3419pub struct Struct_acpi_drtm_resource_list {
3420 pub ResourceCount: UINT32,
3421 pub Resources: [ACPI_DRTM_RESOURCE; 1usize],
3422}
3423impl ::core::clone::Clone for Struct_acpi_drtm_resource_list {
3424 fn clone(&self) -> Self { *self }
3425}
3426impl ::core::default::Default for Struct_acpi_drtm_resource_list {
3427 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3428}
3429pub type ACPI_DRTM_RESOURCE_LIST = Struct_acpi_drtm_resource_list;
3430#[repr(C)]
3431#[derive(Copy)]
3432pub struct Struct_acpi_drtm_dps_id {
3433 pub DpsIdLength: UINT32,
3434 pub DpsId: [UINT8; 16usize],
3435}
3436impl ::core::clone::Clone for Struct_acpi_drtm_dps_id {
3437 fn clone(&self) -> Self { *self }
3438}
3439impl ::core::default::Default for Struct_acpi_drtm_dps_id {
3440 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3441}
3442pub type ACPI_DRTM_DPS_ID = Struct_acpi_drtm_dps_id;
3443#[repr(C)]
3444#[derive(Copy)]
3445pub struct Struct_acpi_table_fpdt {
3446 pub Header: ACPI_TABLE_HEADER,
3447}
3448impl ::core::clone::Clone for Struct_acpi_table_fpdt {
3449 fn clone(&self) -> Self { *self }
3450}
3451impl ::core::default::Default for Struct_acpi_table_fpdt {
3452 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3453}
3454pub type ACPI_TABLE_FPDT = Struct_acpi_table_fpdt;
3455#[repr(C)]
3456#[derive(Copy)]
3457pub struct Struct_acpi_fpdt_header {
3458 pub Type: UINT16,
3459 pub Length: UINT8,
3460 pub Revision: UINT8,
3461}
3462impl ::core::clone::Clone for Struct_acpi_fpdt_header {
3463 fn clone(&self) -> Self { *self }
3464}
3465impl ::core::default::Default for Struct_acpi_fpdt_header {
3466 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3467}
3468pub type ACPI_FPDT_HEADER = Struct_acpi_fpdt_header;
3469#[derive(Clone, Copy)]
3470#[repr(u32)]
3471pub enum Enum_AcpiFpdtType {
3472 ACPI_FPDT_TYPE_BOOT = 0,
3473 ACPI_FPDT_TYPE_S3PERF = 1,
3474}
3475#[repr(C)]
3476#[derive(Copy)]
3477pub struct Struct_acpi_fpdt_boot {
3478 pub Header: ACPI_FPDT_HEADER,
3479 pub Reserved: [UINT8; 4usize],
3480 pub ResetEnd: UINT64,
3481 pub LoadStart: UINT64,
3482 pub StartupStart: UINT64,
3483 pub ExitServicesEntry: UINT64,
3484 pub ExitServicesExit: UINT64,
3485}
3486impl ::core::clone::Clone for Struct_acpi_fpdt_boot {
3487 fn clone(&self) -> Self { *self }
3488}
3489impl ::core::default::Default for Struct_acpi_fpdt_boot {
3490 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3491}
3492pub type ACPI_FPDT_BOOT = Struct_acpi_fpdt_boot;
3493#[repr(C)]
3494#[derive(Copy)]
3495pub struct Struct_acpi_fpdt_s3pt_ptr {
3496 pub Header: ACPI_FPDT_HEADER,
3497 pub Reserved: [UINT8; 4usize],
3498 pub Address: UINT64,
3499}
3500impl ::core::clone::Clone for Struct_acpi_fpdt_s3pt_ptr {
3501 fn clone(&self) -> Self { *self }
3502}
3503impl ::core::default::Default for Struct_acpi_fpdt_s3pt_ptr {
3504 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3505}
3506pub type ACPI_FPDT_S3PT_PTR = Struct_acpi_fpdt_s3pt_ptr;
3507#[repr(C)]
3508#[derive(Copy)]
3509pub struct Struct_acpi_table_s3pt {
3510 pub Signature: [UINT8; 4usize],
3511 pub Length: UINT32,
3512}
3513impl ::core::clone::Clone for Struct_acpi_table_s3pt {
3514 fn clone(&self) -> Self { *self }
3515}
3516impl ::core::default::Default for Struct_acpi_table_s3pt {
3517 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3518}
3519pub type ACPI_TABLE_S3PT = Struct_acpi_table_s3pt;
3520#[repr(C)]
3521#[derive(Copy)]
3522pub struct Struct_acpi_s3pt_header {
3523 pub Type: UINT16,
3524 pub Length: UINT8,
3525 pub Revision: UINT8,
3526}
3527impl ::core::clone::Clone for Struct_acpi_s3pt_header {
3528 fn clone(&self) -> Self { *self }
3529}
3530impl ::core::default::Default for Struct_acpi_s3pt_header {
3531 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3532}
3533pub type ACPI_S3PT_HEADER = Struct_acpi_s3pt_header;
3534#[derive(Clone, Copy)]
3535#[repr(u32)]
3536pub enum Enum_AcpiS3ptType {
3537 ACPI_S3PT_TYPE_RESUME = 0,
3538 ACPI_S3PT_TYPE_SUSPEND = 1,
3539}
3540#[repr(C)]
3541#[derive(Copy)]
3542pub struct Struct_acpi_s3pt_resume {
3543 pub Header: ACPI_S3PT_HEADER,
3544 pub ResumeCount: UINT32,
3545 pub FullResume: UINT64,
3546 pub AverageResume: UINT64,
3547}
3548impl ::core::clone::Clone for Struct_acpi_s3pt_resume {
3549 fn clone(&self) -> Self { *self }
3550}
3551impl ::core::default::Default for Struct_acpi_s3pt_resume {
3552 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3553}
3554pub type ACPI_S3PT_RESUME = Struct_acpi_s3pt_resume;
3555#[repr(C)]
3556#[derive(Copy)]
3557pub struct Struct_acpi_s3pt_suspend {
3558 pub Header: ACPI_S3PT_HEADER,
3559 pub SuspendStart: UINT64,
3560 pub SuspendEnd: UINT64,
3561}
3562impl ::core::clone::Clone for Struct_acpi_s3pt_suspend {
3563 fn clone(&self) -> Self { *self }
3564}
3565impl ::core::default::Default for Struct_acpi_s3pt_suspend {
3566 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3567}
3568pub type ACPI_S3PT_SUSPEND = Struct_acpi_s3pt_suspend;
3569#[repr(C)]
3570#[derive(Copy)]
3571pub struct Struct_acpi_table_gtdt {
3572 pub Header: ACPI_TABLE_HEADER,
3573 pub CounterBlockAddresss: UINT64,
3574 pub Reserved: UINT32,
3575 pub SecureEl1Interrupt: UINT32,
3576 pub SecureEl1Flags: UINT32,
3577 pub NonSecureEl1Interrupt: UINT32,
3578 pub NonSecureEl1Flags: UINT32,
3579 pub VirtualTimerInterrupt: UINT32,
3580 pub VirtualTimerFlags: UINT32,
3581 pub NonSecureEl2Interrupt: UINT32,
3582 pub NonSecureEl2Flags: UINT32,
3583 pub CounterReadBlockAddress: UINT64,
3584 pub PlatformTimerCount: UINT32,
3585 pub PlatformTimerOffset: UINT32,
3586}
3587impl ::core::clone::Clone for Struct_acpi_table_gtdt {
3588 fn clone(&self) -> Self { *self }
3589}
3590impl ::core::default::Default for Struct_acpi_table_gtdt {
3591 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3592}
3593pub type ACPI_TABLE_GTDT = Struct_acpi_table_gtdt;
3594#[repr(C)]
3595#[derive(Copy)]
3596pub struct Struct_acpi_gtdt_header {
3597 pub Type: UINT8,
3598 pub Length: UINT16,
3599}
3600impl ::core::clone::Clone for Struct_acpi_gtdt_header {
3601 fn clone(&self) -> Self { *self }
3602}
3603impl ::core::default::Default for Struct_acpi_gtdt_header {
3604 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3605}
3606pub type ACPI_GTDT_HEADER = Struct_acpi_gtdt_header;
3607#[derive(Clone, Copy)]
3608#[repr(u32)]
3609pub enum Enum_AcpiGtdtType {
3610 ACPI_GTDT_TYPE_TIMER_BLOCK = 0,
3611 ACPI_GTDT_TYPE_WATCHDOG = 1,
3612 ACPI_GTDT_TYPE_RESERVED = 2,
3613}
3614#[repr(C)]
3615#[derive(Copy)]
3616pub struct Struct_acpi_gtdt_timer_block {
3617 pub Header: ACPI_GTDT_HEADER,
3618 pub Reserved: UINT8,
3619 pub BlockAddress: UINT64,
3620 pub TimerCount: UINT32,
3621 pub TimerOffset: UINT32,
3622}
3623impl ::core::clone::Clone for Struct_acpi_gtdt_timer_block {
3624 fn clone(&self) -> Self { *self }
3625}
3626impl ::core::default::Default for Struct_acpi_gtdt_timer_block {
3627 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3628}
3629pub type ACPI_GTDT_TIMER_BLOCK = Struct_acpi_gtdt_timer_block;
3630#[repr(C)]
3631#[derive(Copy)]
3632pub struct Struct_acpi_gtdt_timer_entry {
3633 pub FrameNumber: UINT8,
3634 pub Reserved: [UINT8; 3usize],
3635 pub BaseAddress: UINT64,
3636 pub El0BaseAddress: UINT64,
3637 pub TimerInterrupt: UINT32,
3638 pub TimerFlags: UINT32,
3639 pub VirtualTimerInterrupt: UINT32,
3640 pub VirtualTimerFlags: UINT32,
3641 pub CommonFlags: UINT32,
3642}
3643impl ::core::clone::Clone for Struct_acpi_gtdt_timer_entry {
3644 fn clone(&self) -> Self { *self }
3645}
3646impl ::core::default::Default for Struct_acpi_gtdt_timer_entry {
3647 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3648}
3649pub type ACPI_GTDT_TIMER_ENTRY = Struct_acpi_gtdt_timer_entry;
3650#[repr(C)]
3651#[derive(Copy)]
3652pub struct Struct_acpi_gtdt_watchdog {
3653 pub Header: ACPI_GTDT_HEADER,
3654 pub Reserved: UINT8,
3655 pub RefreshFrameAddress: UINT64,
3656 pub ControlFrameAddress: UINT64,
3657 pub TimerInterrupt: UINT32,
3658 pub TimerFlags: UINT32,
3659}
3660impl ::core::clone::Clone for Struct_acpi_gtdt_watchdog {
3661 fn clone(&self) -> Self { *self }
3662}
3663impl ::core::default::Default for Struct_acpi_gtdt_watchdog {
3664 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3665}
3666pub type ACPI_GTDT_WATCHDOG = Struct_acpi_gtdt_watchdog;
3667#[repr(C)]
3668#[derive(Copy)]
3669pub struct Struct_acpi_table_mpst {
3670 pub Header: ACPI_TABLE_HEADER,
3671 pub ChannelId: UINT8,
3672 pub Reserved1: [UINT8; 3usize],
3673 pub PowerNodeCount: UINT16,
3674 pub Reserved2: UINT16,
3675}
3676impl ::core::clone::Clone for Struct_acpi_table_mpst {
3677 fn clone(&self) -> Self { *self }
3678}
3679impl ::core::default::Default for Struct_acpi_table_mpst {
3680 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3681}
3682pub type ACPI_TABLE_MPST = Struct_acpi_table_mpst;
3683#[repr(C)]
3684#[derive(Copy)]
3685pub struct Struct_acpi_mpst_channel {
3686 pub ChannelId: UINT8,
3687 pub Reserved1: [UINT8; 3usize],
3688 pub PowerNodeCount: UINT16,
3689 pub Reserved2: UINT16,
3690}
3691impl ::core::clone::Clone for Struct_acpi_mpst_channel {
3692 fn clone(&self) -> Self { *self }
3693}
3694impl ::core::default::Default for Struct_acpi_mpst_channel {
3695 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3696}
3697pub type ACPI_MPST_CHANNEL = Struct_acpi_mpst_channel;
3698#[repr(C)]
3699#[derive(Copy)]
3700pub struct Struct_acpi_mpst_power_node {
3701 pub Flags: UINT8,
3702 pub Reserved1: UINT8,
3703 pub NodeId: UINT16,
3704 pub Length: UINT32,
3705 pub RangeAddress: UINT64,
3706 pub RangeLength: UINT64,
3707 pub NumPowerStates: UINT32,
3708 pub NumPhysicalComponents: UINT32,
3709}
3710impl ::core::clone::Clone for Struct_acpi_mpst_power_node {
3711 fn clone(&self) -> Self { *self }
3712}
3713impl ::core::default::Default for Struct_acpi_mpst_power_node {
3714 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3715}
3716pub type ACPI_MPST_POWER_NODE = Struct_acpi_mpst_power_node;
3717#[repr(C)]
3718#[derive(Copy)]
3719pub struct Struct_acpi_mpst_power_state {
3720 pub PowerState: UINT8,
3721 pub InfoIndex: UINT8,
3722}
3723impl ::core::clone::Clone for Struct_acpi_mpst_power_state {
3724 fn clone(&self) -> Self { *self }
3725}
3726impl ::core::default::Default for Struct_acpi_mpst_power_state {
3727 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3728}
3729pub type ACPI_MPST_POWER_STATE = Struct_acpi_mpst_power_state;
3730#[repr(C)]
3731#[derive(Copy)]
3732pub struct Struct_acpi_mpst_component {
3733 pub ComponentId: UINT16,
3734}
3735impl ::core::clone::Clone for Struct_acpi_mpst_component {
3736 fn clone(&self) -> Self { *self }
3737}
3738impl ::core::default::Default for Struct_acpi_mpst_component {
3739 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3740}
3741pub type ACPI_MPST_COMPONENT = Struct_acpi_mpst_component;
3742#[repr(C)]
3743#[derive(Copy)]
3744pub struct Struct_acpi_mpst_data_hdr {
3745 pub CharacteristicsCount: UINT16,
3746 pub Reserved: UINT16,
3747}
3748impl ::core::clone::Clone for Struct_acpi_mpst_data_hdr {
3749 fn clone(&self) -> Self { *self }
3750}
3751impl ::core::default::Default for Struct_acpi_mpst_data_hdr {
3752 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3753}
3754pub type ACPI_MPST_DATA_HDR = Struct_acpi_mpst_data_hdr;
3755#[repr(C)]
3756#[derive(Copy)]
3757pub struct Struct_acpi_mpst_power_data {
3758 pub StructureId: UINT8,
3759 pub Flags: UINT8,
3760 pub Reserved1: UINT16,
3761 pub AveragePower: UINT32,
3762 pub PowerSaving: UINT32,
3763 pub ExitLatency: UINT64,
3764 pub Reserved2: UINT64,
3765}
3766impl ::core::clone::Clone for Struct_acpi_mpst_power_data {
3767 fn clone(&self) -> Self { *self }
3768}
3769impl ::core::default::Default for Struct_acpi_mpst_power_data {
3770 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3771}
3772pub type ACPI_MPST_POWER_DATA = Struct_acpi_mpst_power_data;
3773#[repr(C)]
3774#[derive(Copy)]
3775pub struct Struct_acpi_mpst_shared {
3776 pub Signature: UINT32,
3777 pub PccCommand: UINT16,
3778 pub PccStatus: UINT16,
3779 pub CommandRegister: UINT32,
3780 pub StatusRegister: UINT32,
3781 pub PowerStateId: UINT32,
3782 pub PowerNodeId: UINT32,
3783 pub EnergyConsumed: UINT64,
3784 pub AveragePower: UINT64,
3785}
3786impl ::core::clone::Clone for Struct_acpi_mpst_shared {
3787 fn clone(&self) -> Self { *self }
3788}
3789impl ::core::default::Default for Struct_acpi_mpst_shared {
3790 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3791}
3792pub type ACPI_MPST_SHARED = Struct_acpi_mpst_shared;
3793#[repr(C)]
3794#[derive(Copy)]
3795pub struct Struct_acpi_table_pcct {
3796 pub Header: ACPI_TABLE_HEADER,
3797 pub Flags: UINT32,
3798 pub Reserved: UINT64,
3799}
3800impl ::core::clone::Clone for Struct_acpi_table_pcct {
3801 fn clone(&self) -> Self { *self }
3802}
3803impl ::core::default::Default for Struct_acpi_table_pcct {
3804 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3805}
3806pub type ACPI_TABLE_PCCT = Struct_acpi_table_pcct;
3807#[derive(Clone, Copy)]
3808#[repr(u32)]
3809pub enum Enum_AcpiPcctType {
3810 ACPI_PCCT_TYPE_GENERIC_SUBSPACE = 0,
3811 ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE = 1,
3812 ACPI_PCCT_TYPE_RESERVED = 2,
3813}
3814#[repr(C)]
3815#[derive(Copy)]
3816pub struct Struct_acpi_pcct_subspace {
3817 pub Header: ACPI_SUBTABLE_HEADER,
3818 pub Reserved: [UINT8; 6usize],
3819 pub BaseAddress: UINT64,
3820 pub Length: UINT64,
3821 pub DoorbellRegister: ACPI_GENERIC_ADDRESS,
3822 pub PreserveMask: UINT64,
3823 pub WriteMask: UINT64,
3824 pub Latency: UINT32,
3825 pub MaxAccessRate: UINT32,
3826 pub MinTurnaroundTime: UINT16,
3827}
3828impl ::core::clone::Clone for Struct_acpi_pcct_subspace {
3829 fn clone(&self) -> Self { *self }
3830}
3831impl ::core::default::Default for Struct_acpi_pcct_subspace {
3832 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3833}
3834pub type ACPI_PCCT_SUBSPACE = Struct_acpi_pcct_subspace;
3835#[repr(C)]
3836#[derive(Copy)]
3837pub struct Struct_acpi_pcct_hw_reduced {
3838 pub Header: ACPI_SUBTABLE_HEADER,
3839 pub DoorbellInterrupt: UINT32,
3840 pub Flags: UINT8,
3841 pub Reserved: UINT8,
3842 pub BaseAddress: UINT64,
3843 pub Length: UINT64,
3844 pub DoorbellRegister: ACPI_GENERIC_ADDRESS,
3845 pub PreserveMask: UINT64,
3846 pub WriteMask: UINT64,
3847 pub Latency: UINT32,
3848 pub MaxAccessRate: UINT32,
3849 pub MinTurnaroundTime: UINT16,
3850}
3851impl ::core::clone::Clone for Struct_acpi_pcct_hw_reduced {
3852 fn clone(&self) -> Self { *self }
3853}
3854impl ::core::default::Default for Struct_acpi_pcct_hw_reduced {
3855 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3856}
3857pub type ACPI_PCCT_HW_REDUCED = Struct_acpi_pcct_hw_reduced;
3858#[repr(C)]
3859#[derive(Copy)]
3860pub struct Struct_acpi_pcct_shared_memory {
3861 pub Signature: UINT32,
3862 pub Command: UINT16,
3863 pub Status: UINT16,
3864}
3865impl ::core::clone::Clone for Struct_acpi_pcct_shared_memory {
3866 fn clone(&self) -> Self { *self }
3867}
3868impl ::core::default::Default for Struct_acpi_pcct_shared_memory {
3869 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3870}
3871pub type ACPI_PCCT_SHARED_MEMORY = Struct_acpi_pcct_shared_memory;
3872#[repr(C)]
3873#[derive(Copy)]
3874pub struct Struct_acpi_table_pmtt {
3875 pub Header: ACPI_TABLE_HEADER,
3876 pub Reserved: UINT32,
3877}
3878impl ::core::clone::Clone for Struct_acpi_table_pmtt {
3879 fn clone(&self) -> Self { *self }
3880}
3881impl ::core::default::Default for Struct_acpi_table_pmtt {
3882 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3883}
3884pub type ACPI_TABLE_PMTT = Struct_acpi_table_pmtt;
3885#[repr(C)]
3886#[derive(Copy)]
3887pub struct Struct_acpi_pmtt_header {
3888 pub Type: UINT8,
3889 pub Reserved1: UINT8,
3890 pub Length: UINT16,
3891 pub Flags: UINT16,
3892 pub Reserved2: UINT16,
3893}
3894impl ::core::clone::Clone for Struct_acpi_pmtt_header {
3895 fn clone(&self) -> Self { *self }
3896}
3897impl ::core::default::Default for Struct_acpi_pmtt_header {
3898 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3899}
3900pub type ACPI_PMTT_HEADER = Struct_acpi_pmtt_header;
3901#[repr(C)]
3902#[derive(Copy)]
3903pub struct Struct_acpi_pmtt_socket {
3904 pub Header: ACPI_PMTT_HEADER,
3905 pub SocketId: UINT16,
3906 pub Reserved: UINT16,
3907}
3908impl ::core::clone::Clone for Struct_acpi_pmtt_socket {
3909 fn clone(&self) -> Self { *self }
3910}
3911impl ::core::default::Default for Struct_acpi_pmtt_socket {
3912 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3913}
3914pub type ACPI_PMTT_SOCKET = Struct_acpi_pmtt_socket;
3915#[repr(C)]
3916#[derive(Copy)]
3917pub struct Struct_acpi_pmtt_controller {
3918 pub Header: ACPI_PMTT_HEADER,
3919 pub ReadLatency: UINT32,
3920 pub WriteLatency: UINT32,
3921 pub ReadBandwidth: UINT32,
3922 pub WriteBandwidth: UINT32,
3923 pub AccessWidth: UINT16,
3924 pub Alignment: UINT16,
3925 pub Reserved: UINT16,
3926 pub DomainCount: UINT16,
3927}
3928impl ::core::clone::Clone for Struct_acpi_pmtt_controller {
3929 fn clone(&self) -> Self { *self }
3930}
3931impl ::core::default::Default for Struct_acpi_pmtt_controller {
3932 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3933}
3934pub type ACPI_PMTT_CONTROLLER = Struct_acpi_pmtt_controller;
3935#[repr(C)]
3936#[derive(Copy)]
3937pub struct Struct_acpi_pmtt_domain {
3938 pub ProximityDomain: UINT32,
3939}
3940impl ::core::clone::Clone for Struct_acpi_pmtt_domain {
3941 fn clone(&self) -> Self { *self }
3942}
3943impl ::core::default::Default for Struct_acpi_pmtt_domain {
3944 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3945}
3946pub type ACPI_PMTT_DOMAIN = Struct_acpi_pmtt_domain;
3947#[repr(C)]
3948#[derive(Copy)]
3949pub struct Struct_acpi_pmtt_physical_component {
3950 pub Header: ACPI_PMTT_HEADER,
3951 pub ComponentId: UINT16,
3952 pub Reserved: UINT16,
3953 pub MemorySize: UINT32,
3954 pub BiosHandle: UINT32,
3955}
3956impl ::core::clone::Clone for Struct_acpi_pmtt_physical_component {
3957 fn clone(&self) -> Self { *self }
3958}
3959impl ::core::default::Default for Struct_acpi_pmtt_physical_component {
3960 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3961}
3962pub type ACPI_PMTT_PHYSICAL_COMPONENT = Struct_acpi_pmtt_physical_component;
3963#[repr(C)]
3964#[derive(Copy)]
3965pub struct Struct_acpi_table_rasf {
3966 pub Header: ACPI_TABLE_HEADER,
3967 pub ChannelId: [UINT8; 12usize],
3968}
3969impl ::core::clone::Clone for Struct_acpi_table_rasf {
3970 fn clone(&self) -> Self { *self }
3971}
3972impl ::core::default::Default for Struct_acpi_table_rasf {
3973 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3974}
3975pub type ACPI_TABLE_RASF = Struct_acpi_table_rasf;
3976#[repr(C)]
3977#[derive(Copy)]
3978pub struct Struct_acpi_rasf_shared_memory {
3979 pub Signature: UINT32,
3980 pub Command: UINT16,
3981 pub Status: UINT16,
3982 pub Version: UINT16,
3983 pub Capabilities: [UINT8; 16usize],
3984 pub SetCapabilities: [UINT8; 16usize],
3985 pub NumParameterBlocks: UINT16,
3986 pub SetCapabilitiesStatus: UINT32,
3987}
3988impl ::core::clone::Clone for Struct_acpi_rasf_shared_memory {
3989 fn clone(&self) -> Self { *self }
3990}
3991impl ::core::default::Default for Struct_acpi_rasf_shared_memory {
3992 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
3993}
3994pub type ACPI_RASF_SHARED_MEMORY = Struct_acpi_rasf_shared_memory;
3995#[repr(C)]
3996#[derive(Copy)]
3997pub struct Struct_acpi_rasf_parameter_block {
3998 pub Type: UINT16,
3999 pub Version: UINT16,
4000 pub Length: UINT16,
4001}
4002impl ::core::clone::Clone for Struct_acpi_rasf_parameter_block {
4003 fn clone(&self) -> Self { *self }
4004}
4005impl ::core::default::Default for Struct_acpi_rasf_parameter_block {
4006 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4007}
4008pub type ACPI_RASF_PARAMETER_BLOCK = Struct_acpi_rasf_parameter_block;
4009#[repr(C)]
4010#[derive(Copy)]
4011pub struct Struct_acpi_rasf_patrol_scrub_parameter {
4012 pub Header: ACPI_RASF_PARAMETER_BLOCK,
4013 pub PatrolScrubCommand: UINT16,
4014 pub RequestedAddressRange: [UINT64; 2usize],
4015 pub ActualAddressRange: [UINT64; 2usize],
4016 pub Flags: UINT16,
4017 pub RequestedSpeed: UINT8,
4018}
4019impl ::core::clone::Clone for Struct_acpi_rasf_patrol_scrub_parameter {
4020 fn clone(&self) -> Self { *self }
4021}
4022impl ::core::default::Default for Struct_acpi_rasf_patrol_scrub_parameter {
4023 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4024}
4025pub type ACPI_RASF_PATROL_SCRUB_PARAMETER =
4026 Struct_acpi_rasf_patrol_scrub_parameter;
4027#[derive(Clone, Copy)]
4028#[repr(u32)]
4029pub enum Enum_AcpiRasfCommands { ACPI_RASF_EXECUTE_RASF_COMMAND = 1, _UNUSED_VARIANT = 2, }
4030#[derive(Clone, Copy)]
4031#[repr(u32)]
4032pub enum Enum_AcpiRasfCapabiliities {
4033 ACPI_HW_PATROL_SCRUB_SUPPORTED = 0,
4034 ACPI_SW_PATROL_SCRUB_EXPOSED = 1,
4035}
4036#[derive(Clone, Copy)]
4037#[repr(u32)]
4038pub enum Enum_AcpiRasfPatrolScrubCommands {
4039 ACPI_RASF_GET_PATROL_PARAMETERS = 1,
4040 ACPI_RASF_START_PATROL_SCRUBBER = 2,
4041 ACPI_RASF_STOP_PATROL_SCRUBBER = 3,
4042}
4043#[derive(Clone, Copy)]
4044#[repr(u32)]
4045pub enum Enum_AcpiRasfStatus {
4046 ACPI_RASF_SUCCESS = 0,
4047 ACPI_RASF_NOT_VALID = 1,
4048 ACPI_RASF_NOT_SUPPORTED = 2,
4049 ACPI_RASF_BUSY = 3,
4050 ACPI_RASF_FAILED = 4,
4051 ACPI_RASF_ABORTED = 5,
4052 ACPI_RASF_INVALID_DATA = 6,
4053}
4054#[repr(C)]
4055#[derive(Copy)]
4056pub struct Struct_acpi_table_stao {
4057 pub Header: ACPI_TABLE_HEADER,
4058 pub IgnoreUart: UINT8,
4059}
4060impl ::core::clone::Clone for Struct_acpi_table_stao {
4061 fn clone(&self) -> Self { *self }
4062}
4063impl ::core::default::Default for Struct_acpi_table_stao {
4064 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4065}
4066pub type ACPI_TABLE_STAO = Struct_acpi_table_stao;
4067#[repr(C)]
4068#[derive(Copy)]
4069pub struct Struct_acpi_table_wpbt {
4070 pub Header: ACPI_TABLE_HEADER,
4071 pub HandoffSize: UINT32,
4072 pub HandoffAddress: UINT64,
4073 pub Layout: UINT8,
4074 pub Type: UINT8,
4075 pub ArgumentsLength: UINT16,
4076}
4077impl ::core::clone::Clone for Struct_acpi_table_wpbt {
4078 fn clone(&self) -> Self { *self }
4079}
4080impl ::core::default::Default for Struct_acpi_table_wpbt {
4081 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4082}
4083pub type ACPI_TABLE_WPBT = Struct_acpi_table_wpbt;
4084#[repr(C)]
4085#[derive(Copy)]
4086pub struct Struct_acpi_table_xenv {
4087 pub Header: ACPI_TABLE_HEADER,
4088 pub GrantTableAddress: UINT64,
4089 pub GrantTableSize: UINT64,
4090 pub EventInterrupt: UINT32,
4091 pub EventFlags: UINT8,
4092}
4093impl ::core::clone::Clone for Struct_acpi_table_xenv {
4094 fn clone(&self) -> Self { *self }
4095}
4096impl ::core::default::Default for Struct_acpi_table_xenv {
4097 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4098}
4099pub type ACPI_TABLE_XENV = Struct_acpi_table_xenv;
4100pub type ACPI_RS_LENGTH = UINT16;
4101pub type ACPI_RSDESC_SIZE = UINT32;
4102#[repr(C)]
4103#[derive(Copy)]
4104pub struct Struct_acpi_uuid {
4105 pub Data: [UINT8; 16usize],
4106}
4107impl ::core::clone::Clone for Struct_acpi_uuid {
4108 fn clone(&self) -> Self { *self }
4109}
4110impl ::core::default::Default for Struct_acpi_uuid {
4111 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4112}
4113pub type ACPI_UUID = Struct_acpi_uuid;
4114#[repr(C)]
4115#[derive(Copy)]
4116pub struct Struct_acpi_vendor_uuid {
4117 pub Subtype: UINT8,
4118 pub Data: [UINT8; 16usize],
4119}
4120impl ::core::clone::Clone for Struct_acpi_vendor_uuid {
4121 fn clone(&self) -> Self { *self }
4122}
4123impl ::core::default::Default for Struct_acpi_vendor_uuid {
4124 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4125}
4126pub type ACPI_VENDOR_UUID = Struct_acpi_vendor_uuid;
4127#[repr(C)]
4128#[derive(Copy)]
4129pub struct Struct_acpi_resource_irq {
4130 pub DescriptorLength: UINT8,
4131 pub Triggering: UINT8,
4132 pub Polarity: UINT8,
4133 pub Sharable: UINT8,
4134 pub WakeCapable: UINT8,
4135 pub InterruptCount: UINT8,
4136 pub Interrupts: [UINT8; 1usize],
4137}
4138impl ::core::clone::Clone for Struct_acpi_resource_irq {
4139 fn clone(&self) -> Self { *self }
4140}
4141impl ::core::default::Default for Struct_acpi_resource_irq {
4142 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4143}
4144pub type ACPI_RESOURCE_IRQ = Struct_acpi_resource_irq;
4145#[repr(C)]
4146#[derive(Copy)]
4147pub struct Struct_acpi_resource_dma {
4148 pub Type: UINT8,
4149 pub BusMaster: UINT8,
4150 pub Transfer: UINT8,
4151 pub ChannelCount: UINT8,
4152 pub Channels: [UINT8; 1usize],
4153}
4154impl ::core::clone::Clone for Struct_acpi_resource_dma {
4155 fn clone(&self) -> Self { *self }
4156}
4157impl ::core::default::Default for Struct_acpi_resource_dma {
4158 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4159}
4160pub type ACPI_RESOURCE_DMA = Struct_acpi_resource_dma;
4161#[repr(C)]
4162#[derive(Copy)]
4163pub struct Struct_acpi_resource_start_dependent {
4164 pub DescriptorLength: UINT8,
4165 pub CompatibilityPriority: UINT8,
4166 pub PerformanceRobustness: UINT8,
4167}
4168impl ::core::clone::Clone for Struct_acpi_resource_start_dependent {
4169 fn clone(&self) -> Self { *self }
4170}
4171impl ::core::default::Default for Struct_acpi_resource_start_dependent {
4172 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4173}
4174pub type ACPI_RESOURCE_START_DEPENDENT = Struct_acpi_resource_start_dependent;
4175#[repr(C)]
4176#[derive(Copy)]
4177pub struct Struct_acpi_resource_io {
4178 pub IoDecode: UINT8,
4179 pub Alignment: UINT8,
4180 pub AddressLength: UINT8,
4181 pub Minimum: UINT16,
4182 pub Maximum: UINT16,
4183}
4184impl ::core::clone::Clone for Struct_acpi_resource_io {
4185 fn clone(&self) -> Self { *self }
4186}
4187impl ::core::default::Default for Struct_acpi_resource_io {
4188 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4189}
4190pub type ACPI_RESOURCE_IO = Struct_acpi_resource_io;
4191#[repr(C)]
4192#[derive(Copy)]
4193pub struct Struct_acpi_resource_fixed_io {
4194 pub Address: UINT16,
4195 pub AddressLength: UINT8,
4196}
4197impl ::core::clone::Clone for Struct_acpi_resource_fixed_io {
4198 fn clone(&self) -> Self { *self }
4199}
4200impl ::core::default::Default for Struct_acpi_resource_fixed_io {
4201 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4202}
4203pub type ACPI_RESOURCE_FIXED_IO = Struct_acpi_resource_fixed_io;
4204#[repr(C)]
4205#[derive(Copy)]
4206pub struct Struct_acpi_resource_fixed_dma {
4207 pub RequestLines: UINT16,
4208 pub Channels: UINT16,
4209 pub Width: UINT8,
4210}
4211impl ::core::clone::Clone for Struct_acpi_resource_fixed_dma {
4212 fn clone(&self) -> Self { *self }
4213}
4214impl ::core::default::Default for Struct_acpi_resource_fixed_dma {
4215 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4216}
4217pub type ACPI_RESOURCE_FIXED_DMA = Struct_acpi_resource_fixed_dma;
4218#[repr(C)]
4219#[derive(Copy)]
4220pub struct Struct_acpi_resource_vendor {
4221 pub ByteLength: UINT16,
4222 pub ByteData: [UINT8; 1usize],
4223}
4224impl ::core::clone::Clone for Struct_acpi_resource_vendor {
4225 fn clone(&self) -> Self { *self }
4226}
4227impl ::core::default::Default for Struct_acpi_resource_vendor {
4228 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4229}
4230pub type ACPI_RESOURCE_VENDOR = Struct_acpi_resource_vendor;
4231#[repr(C)]
4232#[derive(Copy)]
4233pub struct Struct_acpi_resource_vendor_typed {
4234 pub ByteLength: UINT16,
4235 pub UuidSubtype: UINT8,
4236 pub Uuid: [UINT8; 16usize],
4237 pub ByteData: [UINT8; 1usize],
4238}
4239impl ::core::clone::Clone for Struct_acpi_resource_vendor_typed {
4240 fn clone(&self) -> Self { *self }
4241}
4242impl ::core::default::Default for Struct_acpi_resource_vendor_typed {
4243 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4244}
4245pub type ACPI_RESOURCE_VENDOR_TYPED = Struct_acpi_resource_vendor_typed;
4246#[repr(C)]
4247#[derive(Copy)]
4248pub struct Struct_acpi_resource_end_tag {
4249 pub Checksum: UINT8,
4250}
4251impl ::core::clone::Clone for Struct_acpi_resource_end_tag {
4252 fn clone(&self) -> Self { *self }
4253}
4254impl ::core::default::Default for Struct_acpi_resource_end_tag {
4255 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4256}
4257pub type ACPI_RESOURCE_END_TAG = Struct_acpi_resource_end_tag;
4258#[repr(C)]
4259#[derive(Copy)]
4260pub struct Struct_acpi_resource_memory24 {
4261 pub WriteProtect: UINT8,
4262 pub Minimum: UINT16,
4263 pub Maximum: UINT16,
4264 pub Alignment: UINT16,
4265 pub AddressLength: UINT16,
4266}
4267impl ::core::clone::Clone for Struct_acpi_resource_memory24 {
4268 fn clone(&self) -> Self { *self }
4269}
4270impl ::core::default::Default for Struct_acpi_resource_memory24 {
4271 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4272}
4273pub type ACPI_RESOURCE_MEMORY24 = Struct_acpi_resource_memory24;
4274#[repr(C)]
4275#[derive(Copy)]
4276pub struct Struct_acpi_resource_memory32 {
4277 pub WriteProtect: UINT8,
4278 pub Minimum: UINT32,
4279 pub Maximum: UINT32,
4280 pub Alignment: UINT32,
4281 pub AddressLength: UINT32,
4282}
4283impl ::core::clone::Clone for Struct_acpi_resource_memory32 {
4284 fn clone(&self) -> Self { *self }
4285}
4286impl ::core::default::Default for Struct_acpi_resource_memory32 {
4287 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4288}
4289pub type ACPI_RESOURCE_MEMORY32 = Struct_acpi_resource_memory32;
4290#[repr(C)]
4291#[derive(Copy)]
4292pub struct Struct_acpi_resource_fixed_memory32 {
4293 pub WriteProtect: UINT8,
4294 pub Address: UINT32,
4295 pub AddressLength: UINT32,
4296}
4297impl ::core::clone::Clone for Struct_acpi_resource_fixed_memory32 {
4298 fn clone(&self) -> Self { *self }
4299}
4300impl ::core::default::Default for Struct_acpi_resource_fixed_memory32 {
4301 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4302}
4303pub type ACPI_RESOURCE_FIXED_MEMORY32 = Struct_acpi_resource_fixed_memory32;
4304#[repr(C)]
4305#[derive(Copy)]
4306pub struct Struct_acpi_memory_attribute {
4307 pub WriteProtect: UINT8,
4308 pub Caching: UINT8,
4309 pub RangeType: UINT8,
4310 pub Translation: UINT8,
4311}
4312impl ::core::clone::Clone for Struct_acpi_memory_attribute {
4313 fn clone(&self) -> Self { *self }
4314}
4315impl ::core::default::Default for Struct_acpi_memory_attribute {
4316 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4317}
4318pub type ACPI_MEMORY_ATTRIBUTE = Struct_acpi_memory_attribute;
4319#[repr(C)]
4320#[derive(Copy)]
4321pub struct Struct_acpi_io_attribute {
4322 pub RangeType: UINT8,
4323 pub Translation: UINT8,
4324 pub TranslationType: UINT8,
4325 pub Reserved1: UINT8,
4326}
4327impl ::core::clone::Clone for Struct_acpi_io_attribute {
4328 fn clone(&self) -> Self { *self }
4329}
4330impl ::core::default::Default for Struct_acpi_io_attribute {
4331 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4332}
4333pub type ACPI_IO_ATTRIBUTE = Struct_acpi_io_attribute;
4334#[repr(C)]
4335#[derive(Copy)]
4336pub struct Union_acpi_resource_attribute {
4337 pub _bindgen_data_: [u8; 4usize],
4338}
4339impl Union_acpi_resource_attribute {
4340 pub unsafe fn Mem(&mut self) -> *mut ACPI_MEMORY_ATTRIBUTE {
4341 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4342 ::core::mem::transmute(raw.offset(0))
4343 }
4344 pub unsafe fn Io(&mut self) -> *mut ACPI_IO_ATTRIBUTE {
4345 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4346 ::core::mem::transmute(raw.offset(0))
4347 }
4348 pub unsafe fn TypeSpecific(&mut self) -> *mut UINT8 {
4349 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4350 ::core::mem::transmute(raw.offset(0))
4351 }
4352}
4353impl ::core::clone::Clone for Union_acpi_resource_attribute {
4354 fn clone(&self) -> Self { *self }
4355}
4356impl ::core::default::Default for Union_acpi_resource_attribute {
4357 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4358}
4359pub type ACPI_RESOURCE_ATTRIBUTE = Union_acpi_resource_attribute;
4360#[repr(C)]
4361#[derive(Copy)]
4362pub struct Struct_acpi_resource_source {
4363 pub Index: UINT8,
4364 pub StringLength: UINT16,
4365 pub StringPtr: *mut i8,
4366}
4367impl ::core::clone::Clone for Struct_acpi_resource_source {
4368 fn clone(&self) -> Self { *self }
4369}
4370impl ::core::default::Default for Struct_acpi_resource_source {
4371 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4372}
4373pub type ACPI_RESOURCE_SOURCE = Struct_acpi_resource_source;
4374#[repr(C)]
4375#[derive(Copy)]
4376pub struct Struct_acpi_address16_attribute {
4377 pub Granularity: UINT16,
4378 pub Minimum: UINT16,
4379 pub Maximum: UINT16,
4380 pub TranslationOffset: UINT16,
4381 pub AddressLength: UINT16,
4382}
4383impl ::core::clone::Clone for Struct_acpi_address16_attribute {
4384 fn clone(&self) -> Self { *self }
4385}
4386impl ::core::default::Default for Struct_acpi_address16_attribute {
4387 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4388}
4389pub type ACPI_ADDRESS16_ATTRIBUTE = Struct_acpi_address16_attribute;
4390#[repr(C)]
4391#[derive(Copy)]
4392pub struct Struct_acpi_address32_attribute {
4393 pub Granularity: UINT32,
4394 pub Minimum: UINT32,
4395 pub Maximum: UINT32,
4396 pub TranslationOffset: UINT32,
4397 pub AddressLength: UINT32,
4398}
4399impl ::core::clone::Clone for Struct_acpi_address32_attribute {
4400 fn clone(&self) -> Self { *self }
4401}
4402impl ::core::default::Default for Struct_acpi_address32_attribute {
4403 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4404}
4405pub type ACPI_ADDRESS32_ATTRIBUTE = Struct_acpi_address32_attribute;
4406#[repr(C)]
4407#[derive(Copy)]
4408pub struct Struct_acpi_address64_attribute {
4409 pub Granularity: UINT64,
4410 pub Minimum: UINT64,
4411 pub Maximum: UINT64,
4412 pub TranslationOffset: UINT64,
4413 pub AddressLength: UINT64,
4414}
4415impl ::core::clone::Clone for Struct_acpi_address64_attribute {
4416 fn clone(&self) -> Self { *self }
4417}
4418impl ::core::default::Default for Struct_acpi_address64_attribute {
4419 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4420}
4421pub type ACPI_ADDRESS64_ATTRIBUTE = Struct_acpi_address64_attribute;
4422#[repr(C)]
4423#[derive(Copy)]
4424pub struct Struct_acpi_resource_address {
4425 pub ResourceType: UINT8,
4426 pub ProducerConsumer: UINT8,
4427 pub Decode: UINT8,
4428 pub MinAddressFixed: UINT8,
4429 pub MaxAddressFixed: UINT8,
4430 pub Info: ACPI_RESOURCE_ATTRIBUTE,
4431}
4432impl ::core::clone::Clone for Struct_acpi_resource_address {
4433 fn clone(&self) -> Self { *self }
4434}
4435impl ::core::default::Default for Struct_acpi_resource_address {
4436 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4437}
4438pub type ACPI_RESOURCE_ADDRESS = Struct_acpi_resource_address;
4439#[repr(C)]
4440#[derive(Copy)]
4441pub struct Struct_acpi_resource_address16 {
4442 pub ResourceType: UINT8,
4443 pub ProducerConsumer: UINT8,
4444 pub Decode: UINT8,
4445 pub MinAddressFixed: UINT8,
4446 pub MaxAddressFixed: UINT8,
4447 pub Info: ACPI_RESOURCE_ATTRIBUTE,
4448 pub Address: ACPI_ADDRESS16_ATTRIBUTE,
4449 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4450}
4451impl ::core::clone::Clone for Struct_acpi_resource_address16 {
4452 fn clone(&self) -> Self { *self }
4453}
4454impl ::core::default::Default for Struct_acpi_resource_address16 {
4455 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4456}
4457pub type ACPI_RESOURCE_ADDRESS16 = Struct_acpi_resource_address16;
4458#[repr(C)]
4459#[derive(Copy)]
4460pub struct Struct_acpi_resource_address32 {
4461 pub ResourceType: UINT8,
4462 pub ProducerConsumer: UINT8,
4463 pub Decode: UINT8,
4464 pub MinAddressFixed: UINT8,
4465 pub MaxAddressFixed: UINT8,
4466 pub Info: ACPI_RESOURCE_ATTRIBUTE,
4467 pub Address: ACPI_ADDRESS32_ATTRIBUTE,
4468 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4469}
4470impl ::core::clone::Clone for Struct_acpi_resource_address32 {
4471 fn clone(&self) -> Self { *self }
4472}
4473impl ::core::default::Default for Struct_acpi_resource_address32 {
4474 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4475}
4476pub type ACPI_RESOURCE_ADDRESS32 = Struct_acpi_resource_address32;
4477#[repr(C)]
4478#[derive(Copy)]
4479pub struct Struct_acpi_resource_address64 {
4480 pub ResourceType: UINT8,
4481 pub ProducerConsumer: UINT8,
4482 pub Decode: UINT8,
4483 pub MinAddressFixed: UINT8,
4484 pub MaxAddressFixed: UINT8,
4485 pub Info: ACPI_RESOURCE_ATTRIBUTE,
4486 pub Address: ACPI_ADDRESS64_ATTRIBUTE,
4487 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4488}
4489impl ::core::clone::Clone for Struct_acpi_resource_address64 {
4490 fn clone(&self) -> Self { *self }
4491}
4492impl ::core::default::Default for Struct_acpi_resource_address64 {
4493 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4494}
4495pub type ACPI_RESOURCE_ADDRESS64 = Struct_acpi_resource_address64;
4496#[repr(C)]
4497#[derive(Copy)]
4498pub struct Struct_acpi_resource_extended_address64 {
4499 pub ResourceType: UINT8,
4500 pub ProducerConsumer: UINT8,
4501 pub Decode: UINT8,
4502 pub MinAddressFixed: UINT8,
4503 pub MaxAddressFixed: UINT8,
4504 pub Info: ACPI_RESOURCE_ATTRIBUTE,
4505 pub RevisionID: UINT8,
4506 pub Address: ACPI_ADDRESS64_ATTRIBUTE,
4507 pub TypeSpecific: UINT64,
4508}
4509impl ::core::clone::Clone for Struct_acpi_resource_extended_address64 {
4510 fn clone(&self) -> Self { *self }
4511}
4512impl ::core::default::Default for Struct_acpi_resource_extended_address64 {
4513 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4514}
4515pub type ACPI_RESOURCE_EXTENDED_ADDRESS64 =
4516 Struct_acpi_resource_extended_address64;
4517#[repr(C)]
4518#[derive(Copy)]
4519pub struct Struct_acpi_resource_extended_irq {
4520 pub ProducerConsumer: UINT8,
4521 pub Triggering: UINT8,
4522 pub Polarity: UINT8,
4523 pub Sharable: UINT8,
4524 pub WakeCapable: UINT8,
4525 pub InterruptCount: UINT8,
4526 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4527 pub Interrupts: [UINT32; 1usize],
4528}
4529impl ::core::clone::Clone for Struct_acpi_resource_extended_irq {
4530 fn clone(&self) -> Self { *self }
4531}
4532impl ::core::default::Default for Struct_acpi_resource_extended_irq {
4533 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4534}
4535pub type ACPI_RESOURCE_EXTENDED_IRQ = Struct_acpi_resource_extended_irq;
4536#[repr(C)]
4537#[derive(Copy)]
4538pub struct Struct_acpi_resource_generic_register {
4539 pub SpaceId: UINT8,
4540 pub BitWidth: UINT8,
4541 pub BitOffset: UINT8,
4542 pub AccessSize: UINT8,
4543 pub Address: UINT64,
4544}
4545impl ::core::clone::Clone for Struct_acpi_resource_generic_register {
4546 fn clone(&self) -> Self { *self }
4547}
4548impl ::core::default::Default for Struct_acpi_resource_generic_register {
4549 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4550}
4551pub type ACPI_RESOURCE_GENERIC_REGISTER =
4552 Struct_acpi_resource_generic_register;
4553#[repr(C)]
4554#[derive(Copy)]
4555pub struct Struct_acpi_resource_gpio {
4556 pub RevisionId: UINT8,
4557 pub ConnectionType: UINT8,
4558 pub ProducerConsumer: UINT8,
4559 pub PinConfig: UINT8,
4560 pub Sharable: UINT8,
4561 pub WakeCapable: UINT8,
4562 pub IoRestriction: UINT8,
4563 pub Triggering: UINT8,
4564 pub Polarity: UINT8,
4565 pub DriveStrength: UINT16,
4566 pub DebounceTimeout: UINT16,
4567 pub PinTableLength: UINT16,
4568 pub VendorLength: UINT16,
4569 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4570 pub PinTable: *mut UINT16,
4571 pub VendorData: *mut UINT8,
4572}
4573impl ::core::clone::Clone for Struct_acpi_resource_gpio {
4574 fn clone(&self) -> Self { *self }
4575}
4576impl ::core::default::Default for Struct_acpi_resource_gpio {
4577 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4578}
4579pub type ACPI_RESOURCE_GPIO = Struct_acpi_resource_gpio;
4580#[repr(C)]
4581#[derive(Copy)]
4582pub struct Struct_acpi_resource_common_serialbus {
4583 pub RevisionId: UINT8,
4584 pub Type: UINT8,
4585 pub ProducerConsumer: UINT8,
4586 pub SlaveMode: UINT8,
4587 pub TypeRevisionId: UINT8,
4588 pub TypeDataLength: UINT16,
4589 pub VendorLength: UINT16,
4590 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4591 pub VendorData: *mut UINT8,
4592}
4593impl ::core::clone::Clone for Struct_acpi_resource_common_serialbus {
4594 fn clone(&self) -> Self { *self }
4595}
4596impl ::core::default::Default for Struct_acpi_resource_common_serialbus {
4597 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4598}
4599pub type ACPI_RESOURCE_COMMON_SERIALBUS =
4600 Struct_acpi_resource_common_serialbus;
4601#[repr(C)]
4602#[derive(Copy)]
4603pub struct Struct_acpi_resource_i2c_serialbus {
4604 pub RevisionId: UINT8,
4605 pub Type: UINT8,
4606 pub ProducerConsumer: UINT8,
4607 pub SlaveMode: UINT8,
4608 pub TypeRevisionId: UINT8,
4609 pub TypeDataLength: UINT16,
4610 pub VendorLength: UINT16,
4611 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4612 pub VendorData: *mut UINT8,
4613 pub AccessMode: UINT8,
4614 pub SlaveAddress: UINT16,
4615 pub ConnectionSpeed: UINT32,
4616}
4617impl ::core::clone::Clone for Struct_acpi_resource_i2c_serialbus {
4618 fn clone(&self) -> Self { *self }
4619}
4620impl ::core::default::Default for Struct_acpi_resource_i2c_serialbus {
4621 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4622}
4623pub type ACPI_RESOURCE_I2C_SERIALBUS = Struct_acpi_resource_i2c_serialbus;
4624#[repr(C)]
4625#[derive(Copy)]
4626pub struct Struct_acpi_resource_spi_serialbus {
4627 pub RevisionId: UINT8,
4628 pub Type: UINT8,
4629 pub ProducerConsumer: UINT8,
4630 pub SlaveMode: UINT8,
4631 pub TypeRevisionId: UINT8,
4632 pub TypeDataLength: UINT16,
4633 pub VendorLength: UINT16,
4634 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4635 pub VendorData: *mut UINT8,
4636 pub WireMode: UINT8,
4637 pub DevicePolarity: UINT8,
4638 pub DataBitLength: UINT8,
4639 pub ClockPhase: UINT8,
4640 pub ClockPolarity: UINT8,
4641 pub DeviceSelection: UINT16,
4642 pub ConnectionSpeed: UINT32,
4643}
4644impl ::core::clone::Clone for Struct_acpi_resource_spi_serialbus {
4645 fn clone(&self) -> Self { *self }
4646}
4647impl ::core::default::Default for Struct_acpi_resource_spi_serialbus {
4648 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4649}
4650pub type ACPI_RESOURCE_SPI_SERIALBUS = Struct_acpi_resource_spi_serialbus;
4651#[repr(C)]
4652#[derive(Copy)]
4653pub struct Struct_acpi_resource_uart_serialbus {
4654 pub RevisionId: UINT8,
4655 pub Type: UINT8,
4656 pub ProducerConsumer: UINT8,
4657 pub SlaveMode: UINT8,
4658 pub TypeRevisionId: UINT8,
4659 pub TypeDataLength: UINT16,
4660 pub VendorLength: UINT16,
4661 pub ResourceSource: ACPI_RESOURCE_SOURCE,
4662 pub VendorData: *mut UINT8,
4663 pub Endian: UINT8,
4664 pub DataBits: UINT8,
4665 pub StopBits: UINT8,
4666 pub FlowControl: UINT8,
4667 pub Parity: UINT8,
4668 pub LinesEnabled: UINT8,
4669 pub RxFifoSize: UINT16,
4670 pub TxFifoSize: UINT16,
4671 pub DefaultBaudRate: UINT32,
4672}
4673impl ::core::clone::Clone for Struct_acpi_resource_uart_serialbus {
4674 fn clone(&self) -> Self { *self }
4675}
4676impl ::core::default::Default for Struct_acpi_resource_uart_serialbus {
4677 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4678}
4679pub type ACPI_RESOURCE_UART_SERIALBUS = Struct_acpi_resource_uart_serialbus;
4680#[repr(C)]
4681#[derive(Copy)]
4682pub struct Union_acpi_resource_data {
4683 pub _bindgen_data_: [u8; 60usize],
4684}
4685impl Union_acpi_resource_data {
4686 pub unsafe fn Irq(&mut self) -> *mut ACPI_RESOURCE_IRQ {
4687 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4688 ::core::mem::transmute(raw.offset(0))
4689 }
4690 pub unsafe fn Dma(&mut self) -> *mut ACPI_RESOURCE_DMA {
4691 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4692 ::core::mem::transmute(raw.offset(0))
4693 }
4694 pub unsafe fn StartDpf(&mut self) -> *mut ACPI_RESOURCE_START_DEPENDENT {
4695 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4696 ::core::mem::transmute(raw.offset(0))
4697 }
4698 pub unsafe fn Io(&mut self) -> *mut ACPI_RESOURCE_IO {
4699 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4700 ::core::mem::transmute(raw.offset(0))
4701 }
4702 pub unsafe fn FixedIo(&mut self) -> *mut ACPI_RESOURCE_FIXED_IO {
4703 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4704 ::core::mem::transmute(raw.offset(0))
4705 }
4706 pub unsafe fn FixedDma(&mut self) -> *mut ACPI_RESOURCE_FIXED_DMA {
4707 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4708 ::core::mem::transmute(raw.offset(0))
4709 }
4710 pub unsafe fn Vendor(&mut self) -> *mut ACPI_RESOURCE_VENDOR {
4711 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4712 ::core::mem::transmute(raw.offset(0))
4713 }
4714 pub unsafe fn VendorTyped(&mut self) -> *mut ACPI_RESOURCE_VENDOR_TYPED {
4715 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4716 ::core::mem::transmute(raw.offset(0))
4717 }
4718 pub unsafe fn EndTag(&mut self) -> *mut ACPI_RESOURCE_END_TAG {
4719 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4720 ::core::mem::transmute(raw.offset(0))
4721 }
4722 pub unsafe fn Memory24(&mut self) -> *mut ACPI_RESOURCE_MEMORY24 {
4723 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4724 ::core::mem::transmute(raw.offset(0))
4725 }
4726 pub unsafe fn Memory32(&mut self) -> *mut ACPI_RESOURCE_MEMORY32 {
4727 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4728 ::core::mem::transmute(raw.offset(0))
4729 }
4730 pub unsafe fn FixedMemory32(&mut self)
4731 -> *mut ACPI_RESOURCE_FIXED_MEMORY32 {
4732 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4733 ::core::mem::transmute(raw.offset(0))
4734 }
4735 pub unsafe fn Address16(&mut self) -> *mut ACPI_RESOURCE_ADDRESS16 {
4736 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4737 ::core::mem::transmute(raw.offset(0))
4738 }
4739 pub unsafe fn Address32(&mut self) -> *mut ACPI_RESOURCE_ADDRESS32 {
4740 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4741 ::core::mem::transmute(raw.offset(0))
4742 }
4743 pub unsafe fn Address64(&mut self) -> *mut ACPI_RESOURCE_ADDRESS64 {
4744 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4745 ::core::mem::transmute(raw.offset(0))
4746 }
4747 pub unsafe fn ExtAddress64(&mut self)
4748 -> *mut ACPI_RESOURCE_EXTENDED_ADDRESS64 {
4749 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4750 ::core::mem::transmute(raw.offset(0))
4751 }
4752 pub unsafe fn ExtendedIrq(&mut self) -> *mut ACPI_RESOURCE_EXTENDED_IRQ {
4753 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4754 ::core::mem::transmute(raw.offset(0))
4755 }
4756 pub unsafe fn GenericReg(&mut self)
4757 -> *mut ACPI_RESOURCE_GENERIC_REGISTER {
4758 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4759 ::core::mem::transmute(raw.offset(0))
4760 }
4761 pub unsafe fn Gpio(&mut self) -> *mut ACPI_RESOURCE_GPIO {
4762 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4763 ::core::mem::transmute(raw.offset(0))
4764 }
4765 pub unsafe fn I2cSerialBus(&mut self)
4766 -> *mut ACPI_RESOURCE_I2C_SERIALBUS {
4767 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4768 ::core::mem::transmute(raw.offset(0))
4769 }
4770 pub unsafe fn SpiSerialBus(&mut self)
4771 -> *mut ACPI_RESOURCE_SPI_SERIALBUS {
4772 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4773 ::core::mem::transmute(raw.offset(0))
4774 }
4775 pub unsafe fn UartSerialBus(&mut self)
4776 -> *mut ACPI_RESOURCE_UART_SERIALBUS {
4777 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4778 ::core::mem::transmute(raw.offset(0))
4779 }
4780 pub unsafe fn CommonSerialBus(&mut self)
4781 -> *mut ACPI_RESOURCE_COMMON_SERIALBUS {
4782 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4783 ::core::mem::transmute(raw.offset(0))
4784 }
4785 pub unsafe fn Address(&mut self) -> *mut ACPI_RESOURCE_ADDRESS {
4786 let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
4787 ::core::mem::transmute(raw.offset(0))
4788 }
4789}
4790impl ::core::clone::Clone for Union_acpi_resource_data {
4791 fn clone(&self) -> Self { *self }
4792}
4793impl ::core::default::Default for Union_acpi_resource_data {
4794 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4795}
4796pub type ACPI_RESOURCE_DATA = Union_acpi_resource_data;
4797#[repr(C)]
4798#[derive(Copy)]
4799pub struct Struct_acpi_resource {
4800 pub Type: UINT32,
4801 pub Length: UINT32,
4802 pub Data: ACPI_RESOURCE_DATA,
4803}
4804impl ::core::clone::Clone for Struct_acpi_resource {
4805 fn clone(&self) -> Self { *self }
4806}
4807impl ::core::default::Default for Struct_acpi_resource {
4808 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4809}
4810pub type ACPI_RESOURCE = Struct_acpi_resource;
4811#[repr(C)]
4812#[derive(Copy)]
4813pub struct Struct_acpi_pci_routing_table {
4814 pub Length: UINT32,
4815 pub Pin: UINT32,
4816 pub Address: UINT64,
4817 pub SourceIndex: UINT32,
4818 pub Source: [i8; 4usize],
4819}
4820impl ::core::clone::Clone for Struct_acpi_pci_routing_table {
4821 fn clone(&self) -> Self { *self }
4822}
4823impl ::core::default::Default for Struct_acpi_pci_routing_table {
4824 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4825}
4826pub type ACPI_PCI_ROUTING_TABLE = Struct_acpi_pci_routing_table;
4827#[derive(Clone, Copy)]
4828#[repr(u32)]
4829pub enum Enum_Unnamed9 {
4830 OSL_GLOBAL_LOCK_HANDLER = 0,
4831 OSL_NOTIFY_HANDLER = 1,
4832 OSL_GPE_HANDLER = 2,
4833 OSL_DEBUGGER_MAIN_THREAD = 3,
4834 OSL_DEBUGGER_EXEC_THREAD = 4,
4835 OSL_EC_POLL_HANDLER = 5,
4836 OSL_EC_BURST_HANDLER = 6,
4837}
4838pub type ACPI_EXECUTE_TYPE = Enum_Unnamed9;
4839#[repr(C)]
4840#[derive(Copy)]
4841pub struct Struct_acpi_signal_fatal_info {
4842 pub Type: UINT32,
4843 pub Code: UINT32,
4844 pub Argument: UINT32,
4845}
4846impl ::core::clone::Clone for Struct_acpi_signal_fatal_info {
4847 fn clone(&self) -> Self { *self }
4848}
4849impl ::core::default::Default for Struct_acpi_signal_fatal_info {
4850 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4851}
4852pub type ACPI_SIGNAL_FATAL_INFO = Struct_acpi_signal_fatal_info;
4853#[repr(C)]
4854#[derive(Copy)]
4855pub struct Struct_acpi_fde_info {
4856 pub Floppy0: UINT32,
4857 pub Floppy1: UINT32,
4858 pub Floppy2: UINT32,
4859 pub Floppy3: UINT32,
4860 pub Tape: UINT32,
4861}
4862impl ::core::clone::Clone for Struct_acpi_fde_info {
4863 fn clone(&self) -> Self { *self }
4864}
4865impl ::core::default::Default for Struct_acpi_fde_info {
4866 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4867}
4868pub type ACPI_FDE_INFO = Struct_acpi_fde_info;
4869#[repr(C)]
4870#[derive(Copy)]
4871pub struct Struct_acpi_grt_info {
4872 pub Year: UINT16,
4873 pub Month: UINT8,
4874 pub Day: UINT8,
4875 pub Hour: UINT8,
4876 pub Minute: UINT8,
4877 pub Second: UINT8,
4878 pub Valid: UINT8,
4879 pub Milliseconds: UINT16,
4880 pub Timezone: UINT16,
4881 pub Daylight: UINT8,
4882 pub Reserved: [UINT8; 3usize],
4883}
4884impl ::core::clone::Clone for Struct_acpi_grt_info {
4885 fn clone(&self) -> Self { *self }
4886}
4887impl ::core::default::Default for Struct_acpi_grt_info {
4888 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4889}
4890pub type ACPI_GRT_INFO = Struct_acpi_grt_info;
4891#[repr(C)]
4892#[derive(Copy)]
4893pub struct Struct_acpi_gtm_info {
4894 pub PioSpeed0: UINT32,
4895 pub DmaSpeed0: UINT32,
4896 pub PioSpeed1: UINT32,
4897 pub DmaSpeed1: UINT32,
4898 pub Flags: UINT32,
4899}
4900impl ::core::clone::Clone for Struct_acpi_gtm_info {
4901 fn clone(&self) -> Self { *self }
4902}
4903impl ::core::default::Default for Struct_acpi_gtm_info {
4904 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4905}
4906pub type ACPI_GTM_INFO = Struct_acpi_gtm_info;
4907#[repr(C)]
4908#[derive(Copy)]
4909pub struct Struct_acpi_pld_info {
4910 pub Revision: UINT8,
4911 pub IgnoreColor: UINT8,
4912 pub Red: UINT8,
4913 pub Green: UINT8,
4914 pub Blue: UINT8,
4915 pub Width: UINT16,
4916 pub Height: UINT16,
4917 pub UserVisible: UINT8,
4918 pub Dock: UINT8,
4919 pub Lid: UINT8,
4920 pub Panel: UINT8,
4921 pub VerticalPosition: UINT8,
4922 pub HorizontalPosition: UINT8,
4923 pub Shape: UINT8,
4924 pub GroupOrientation: UINT8,
4925 pub GroupToken: UINT8,
4926 pub GroupPosition: UINT8,
4927 pub Bay: UINT8,
4928 pub Ejectable: UINT8,
4929 pub OspmEjectRequired: UINT8,
4930 pub CabinetNumber: UINT8,
4931 pub CardCageNumber: UINT8,
4932 pub Reference: UINT8,
4933 pub Rotation: UINT8,
4934 pub Order: UINT8,
4935 pub Reserved: UINT8,
4936 pub VerticalOffset: UINT16,
4937 pub HorizontalOffset: UINT16,
4938}
4939impl ::core::clone::Clone for Struct_acpi_pld_info {
4940 fn clone(&self) -> Self { *self }
4941}
4942impl ::core::default::Default for Struct_acpi_pld_info {
4943 fn default() -> Self { unsafe { ::core::mem::zeroed() } }
4944}
4945pub type ACPI_PLD_INFO = Struct_acpi_pld_info;
4946pub type ACPI_WALK_RESOURCE_CALLBACK =
4947 ::core::option::Option<unsafe extern "C" fn(Resource: *mut ACPI_RESOURCE,
4948 Context:
4949 *mut c_void)
4950 -> ACPI_STATUS>;
4951extern "C" {
4952 pub static mut AcpiGbl_EnableInterpreterSlack: UINT8;
4953 pub static mut AcpiGbl_AutoSerializeMethods: UINT8;
4954 pub static mut AcpiGbl_CreateOsiMethod: UINT8;
4955 pub static mut AcpiGbl_UseDefaultRegisterWidths: UINT8;
4956 pub static mut AcpiGbl_VerifyTableChecksum: UINT8;
4957 pub static mut AcpiGbl_EnableAmlDebugObject: UINT8;
4958 pub static mut AcpiGbl_CopyDsdtLocally: UINT8;
4959 pub static mut AcpiGbl_DoNotUseXsdt: UINT8;
4960 pub static mut AcpiGbl_GroupModuleLevelCode: UINT8;
4961 pub static mut AcpiGbl_Use32BitFadtAddresses: UINT8;
4962 pub static mut AcpiGbl_Use32BitFacsAddresses: UINT8;
4963 pub static mut AcpiGbl_TruncateIoAddresses: UINT8;
4964 pub static mut AcpiGbl_DisableAutoRepair: UINT8;
4965 pub static mut AcpiGbl_DisableSsdtTableInstall: UINT8;
4966 pub static mut AcpiGbl_RuntimeNamespaceOverride: UINT8;
4967 pub static mut AcpiGbl_OsiData: UINT8;
4968 pub static mut AcpiGbl_ReducedHardware: BOOLEAN;
4969 pub static mut AcpiGbl_TraceFlags: UINT32;
4970 pub static mut AcpiGbl_TraceMethodName: *const i8;
4971 pub static mut AcpiGbl_TraceDbgLevel: UINT32;
4972 pub static mut AcpiGbl_TraceDbgLayer: UINT32;
4973 pub static mut AcpiDbgLevel: UINT32;
4974 pub static mut AcpiDbgLayer: UINT32;
4975 pub static mut AcpiGbl_DisplayDebugTimer: UINT8;
4976 pub static mut AcpiGbl_FADT: ACPI_TABLE_FADT;
4977 pub static mut AcpiCurrentGpeCount: UINT32;
4978 pub static mut AcpiGbl_SystemAwakeAndRunning: BOOLEAN;
4979}
4980extern "C" {
4981 pub fn AcpiInitializeTables(InitialStorage: *mut ACPI_TABLE_DESC,
4982 InitialTableCount: UINT32,
4983 AllowResize: BOOLEAN) -> ACPI_STATUS;
4984 pub fn AcpiInitializeSubsystem() -> ACPI_STATUS;
4985 pub fn AcpiEnableSubsystem(Flags: UINT32) -> ACPI_STATUS;
4986 pub fn AcpiInitializeObjects(Flags: UINT32) -> ACPI_STATUS;
4987 pub fn AcpiTerminate() -> ACPI_STATUS;
4988 pub fn AcpiEnable() -> ACPI_STATUS;
4989 pub fn AcpiDisable() -> ACPI_STATUS;
4990 pub fn AcpiSubsystemStatus() -> ACPI_STATUS;
4991 pub fn AcpiGetSystemInfo(RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
4992 pub fn AcpiGetStatistics(Stats: *mut ACPI_STATISTICS) -> ACPI_STATUS;
4993 pub fn AcpiFormatException(Exception: ACPI_STATUS)
4994 -> *const i8;
4995 pub fn AcpiPurgeCachedObjects() -> ACPI_STATUS;
4996 pub fn AcpiInstallInterface(InterfaceName: ACPI_STRING) -> ACPI_STATUS;
4997 pub fn AcpiRemoveInterface(InterfaceName: ACPI_STRING) -> ACPI_STATUS;
4998 pub fn AcpiUpdateInterfaces(Action: UINT8) -> ACPI_STATUS;
4999 pub fn AcpiCheckAddressRange(SpaceId: ACPI_ADR_SPACE_TYPE,
5000 Address: ACPI_PHYSICAL_ADDRESS,
5001 Length: ACPI_SIZE, Warn: BOOLEAN) -> UINT32;
5002 pub fn AcpiDecodePldBuffer(InBuffer: *mut UINT8, Length: ACPI_SIZE,
5003 ReturnBuffer: *mut *mut ACPI_PLD_INFO)
5004 -> ACPI_STATUS;
5005 pub fn AcpiInstallTable(Address: ACPI_PHYSICAL_ADDRESS, Physical: BOOLEAN)
5006 -> ACPI_STATUS;
5007 pub fn AcpiLoadTable(Table: *mut ACPI_TABLE_HEADER) -> ACPI_STATUS;
5008 pub fn AcpiUnloadParentTable(Object: ACPI_HANDLE) -> ACPI_STATUS;
5009 pub fn AcpiLoadTables() -> ACPI_STATUS;
5010 pub fn AcpiReallocateRootTable() -> ACPI_STATUS;
5011 pub fn AcpiFindRootPointer(RsdpAddress: *mut ACPI_PHYSICAL_ADDRESS)
5012 -> ACPI_STATUS;
5013 pub fn AcpiGetTableHeader(Signature: ACPI_STRING, Instance: UINT32,
5014 OutTableHeader: *mut ACPI_TABLE_HEADER)
5015 -> ACPI_STATUS;
5016 pub fn AcpiGetTable(Signature: ACPI_STRING, Instance: UINT32,
5017 OutTable: *mut *mut ACPI_TABLE_HEADER) -> ACPI_STATUS;
5018 pub fn AcpiGetTableByIndex(TableIndex: UINT32,
5019 OutTable: *mut *mut ACPI_TABLE_HEADER)
5020 -> ACPI_STATUS;
5021 pub fn AcpiInstallTableHandler(Handler: ACPI_TABLE_HANDLER,
5022 Context: *mut c_void)
5023 -> ACPI_STATUS;
5024 pub fn AcpiRemoveTableHandler(Handler: ACPI_TABLE_HANDLER) -> ACPI_STATUS;
5025 pub fn AcpiWalkNamespace(Type: ACPI_OBJECT_TYPE, StartObject: ACPI_HANDLE,
5026 MaxDepth: UINT32,
5027 DescendingCallback: ACPI_WALK_CALLBACK,
5028 AscendingCallback: ACPI_WALK_CALLBACK,
5029 Context: *mut c_void,
5030 ReturnValue: *mut *mut c_void)
5031 -> ACPI_STATUS;
5032 pub fn AcpiGetDevices(HID: *mut i8,
5033 UserFunction: ACPI_WALK_CALLBACK,
5034 Context: *mut c_void,
5035 ReturnValue: *mut *mut c_void)
5036 -> ACPI_STATUS;
5037 pub fn AcpiGetName(Object: ACPI_HANDLE, NameType: UINT32,
5038 RetPathPtr: *mut ACPI_BUFFER) -> ACPI_STATUS;
5039 pub fn AcpiGetHandle(Parent: ACPI_HANDLE, Pathname: ACPI_STRING,
5040 RetHandle: *mut ACPI_HANDLE) -> ACPI_STATUS;
5041 pub fn AcpiAttachData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER,
5042 Data: *mut c_void) -> ACPI_STATUS;
5043 pub fn AcpiDetachData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER)
5044 -> ACPI_STATUS;
5045 pub fn AcpiGetData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER,
5046 Data: *mut *mut c_void) -> ACPI_STATUS;
5047 pub fn AcpiDebugTrace(Name: *const i8,
5048 DebugLevel: UINT32, DebugLayer: UINT32,
5049 Flags: UINT32) -> ACPI_STATUS;
5050 pub fn AcpiEvaluateObject(Object: ACPI_HANDLE, Pathname: ACPI_STRING,
5051 ParameterObjects: *mut ACPI_OBJECT_LIST,
5052 ReturnObjectBuffer: *mut ACPI_BUFFER)
5053 -> ACPI_STATUS;
5054 pub fn AcpiEvaluateObjectTyped(Object: ACPI_HANDLE, Pathname: ACPI_STRING,
5055 ExternalParams: *mut ACPI_OBJECT_LIST,
5056 ReturnBuffer: *mut ACPI_BUFFER,
5057 ReturnType: ACPI_OBJECT_TYPE)
5058 -> ACPI_STATUS;
5059 pub fn AcpiGetObjectInfo(Object: ACPI_HANDLE,
5060 ReturnBuffer: *mut *mut ACPI_DEVICE_INFO)
5061 -> ACPI_STATUS;
5062 pub fn AcpiInstallMethod(Buffer: *mut UINT8) -> ACPI_STATUS;
5063 pub fn AcpiGetNextObject(Type: ACPI_OBJECT_TYPE, Parent: ACPI_HANDLE,
5064 Child: ACPI_HANDLE, OutHandle: *mut ACPI_HANDLE)
5065 -> ACPI_STATUS;
5066 pub fn AcpiGetType(Object: ACPI_HANDLE, OutType: *mut ACPI_OBJECT_TYPE)
5067 -> ACPI_STATUS;
5068 pub fn AcpiGetParent(Object: ACPI_HANDLE, OutHandle: *mut ACPI_HANDLE)
5069 -> ACPI_STATUS;
5070 pub fn AcpiInstallInitializationHandler(Handler: ACPI_INIT_HANDLER,
5071 Function: UINT32) -> ACPI_STATUS;
5072 pub fn AcpiInstallSciHandler(Address: ACPI_SCI_HANDLER,
5073 Context: *mut c_void)
5074 -> ACPI_STATUS;
5075 pub fn AcpiRemoveSciHandler(Address: ACPI_SCI_HANDLER) -> ACPI_STATUS;
5076 pub fn AcpiInstallGlobalEventHandler(Handler: ACPI_GBL_EVENT_HANDLER,
5077 Context: *mut c_void)
5078 -> ACPI_STATUS;
5079 pub fn AcpiInstallFixedEventHandler(AcpiEvent: UINT32,
5080 Handler: ACPI_EVENT_HANDLER,
5081 Context: *mut c_void)
5082 -> ACPI_STATUS;
5083 pub fn AcpiRemoveFixedEventHandler(AcpiEvent: UINT32,
5084 Handler: ACPI_EVENT_HANDLER)
5085 -> ACPI_STATUS;
5086 pub fn AcpiInstallGpeHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5087 Type: UINT32, Address: ACPI_GPE_HANDLER,
5088 Context: *mut c_void)
5089 -> ACPI_STATUS;
5090 pub fn AcpiInstallGpeRawHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5091 Type: UINT32, Address: ACPI_GPE_HANDLER,
5092 Context: *mut c_void)
5093 -> ACPI_STATUS;
5094 pub fn AcpiRemoveGpeHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5095 Address: ACPI_GPE_HANDLER) -> ACPI_STATUS;
5096 pub fn AcpiInstallNotifyHandler(Device: ACPI_HANDLE, HandlerType: UINT32,
5097 Handler: ACPI_NOTIFY_HANDLER,
5098 Context: *mut c_void)
5099 -> ACPI_STATUS;
5100 pub fn AcpiRemoveNotifyHandler(Device: ACPI_HANDLE, HandlerType: UINT32,
5101 Handler: ACPI_NOTIFY_HANDLER)
5102 -> ACPI_STATUS;
5103 pub fn AcpiInstallAddressSpaceHandler(Device: ACPI_HANDLE,
5104 SpaceId: ACPI_ADR_SPACE_TYPE,
5105 Handler: ACPI_ADR_SPACE_HANDLER,
5106 Setup: ACPI_ADR_SPACE_SETUP,
5107 Context:
5108 *mut c_void)
5109 -> ACPI_STATUS;
5110 pub fn AcpiRemoveAddressSpaceHandler(Device: ACPI_HANDLE,
5111 SpaceId: ACPI_ADR_SPACE_TYPE,
5112 Handler: ACPI_ADR_SPACE_HANDLER)
5113 -> ACPI_STATUS;
5114 pub fn AcpiInstallExceptionHandler(Handler: ACPI_EXCEPTION_HANDLER)
5115 -> ACPI_STATUS;
5116 pub fn AcpiInstallInterfaceHandler(Handler: ACPI_INTERFACE_HANDLER)
5117 -> ACPI_STATUS;
5118 pub fn AcpiAcquireGlobalLock(Timeout: UINT16, Handle: *mut UINT32)
5119 -> ACPI_STATUS;
5120 pub fn AcpiReleaseGlobalLock(Handle: UINT32) -> ACPI_STATUS;
5121 pub fn AcpiAcquireMutex(Handle: ACPI_HANDLE, Pathname: ACPI_STRING,
5122 Timeout: UINT16) -> ACPI_STATUS;
5123 pub fn AcpiReleaseMutex(Handle: ACPI_HANDLE, Pathname: ACPI_STRING)
5124 -> ACPI_STATUS;
5125 pub fn AcpiEnableEvent(Event: UINT32, Flags: UINT32) -> ACPI_STATUS;
5126 pub fn AcpiDisableEvent(Event: UINT32, Flags: UINT32) -> ACPI_STATUS;
5127 pub fn AcpiClearEvent(Event: UINT32) -> ACPI_STATUS;
5128 pub fn AcpiGetEventStatus(Event: UINT32,
5129 EventStatus: *mut ACPI_EVENT_STATUS)
5130 -> ACPI_STATUS;
5131 pub fn AcpiUpdateAllGpes() -> ACPI_STATUS;
5132 pub fn AcpiEnableGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5133 -> ACPI_STATUS;
5134 pub fn AcpiDisableGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5135 -> ACPI_STATUS;
5136 pub fn AcpiClearGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5137 -> ACPI_STATUS;
5138 pub fn AcpiSetGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5139 Action: UINT8) -> ACPI_STATUS;
5140 pub fn AcpiFinishGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5141 -> ACPI_STATUS;
5142 pub fn AcpiMarkGpeForWake(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5143 -> ACPI_STATUS;
5144 pub fn AcpiSetupGpeForWake(ParentDevice: ACPI_HANDLE,
5145 GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
5146 -> ACPI_STATUS;
5147 pub fn AcpiSetGpeWakeMask(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5148 Action: UINT8) -> ACPI_STATUS;
5149 pub fn AcpiGetGpeStatus(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
5150 EventStatus: *mut ACPI_EVENT_STATUS)
5151 -> ACPI_STATUS;
5152 pub fn AcpiDisableAllGpes() -> ACPI_STATUS;
5153 pub fn AcpiEnableAllRuntimeGpes() -> ACPI_STATUS;
5154 pub fn AcpiEnableAllWakeupGpes() -> ACPI_STATUS;
5155 pub fn AcpiGetGpeDevice(GpeIndex: UINT32, GpeDevice: *mut ACPI_HANDLE)
5156 -> ACPI_STATUS;
5157 pub fn AcpiInstallGpeBlock(GpeDevice: ACPI_HANDLE,
5158 GpeBlockAddress: *mut ACPI_GENERIC_ADDRESS,
5159 RegisterCount: UINT32, InterruptNumber: UINT32)
5160 -> ACPI_STATUS;
5161 pub fn AcpiRemoveGpeBlock(GpeDevice: ACPI_HANDLE) -> ACPI_STATUS;
5162 pub fn AcpiGetVendorResource(Device: ACPI_HANDLE,
5163 Name: *mut i8,
5164 Uuid: *mut ACPI_VENDOR_UUID,
5165 RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
5166 pub fn AcpiGetCurrentResources(Device: ACPI_HANDLE,
5167 RetBuffer: *mut ACPI_BUFFER)
5168 -> ACPI_STATUS;
5169 pub fn AcpiGetPossibleResources(Device: ACPI_HANDLE,
5170 RetBuffer: *mut ACPI_BUFFER)
5171 -> ACPI_STATUS;
5172 pub fn AcpiGetEventResources(DeviceHandle: ACPI_HANDLE,
5173 RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
5174 pub fn AcpiWalkResourceBuffer(Buffer: *mut ACPI_BUFFER,
5175 UserFunction: ACPI_WALK_RESOURCE_CALLBACK,
5176 Context: *mut c_void)
5177 -> ACPI_STATUS;
5178 pub fn AcpiWalkResources(Device: ACPI_HANDLE,
5179 Name: *mut i8,
5180 UserFunction: ACPI_WALK_RESOURCE_CALLBACK,
5181 Context: *mut c_void)
5182 -> ACPI_STATUS;
5183 pub fn AcpiSetCurrentResources(Device: ACPI_HANDLE,
5184 InBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
5185 pub fn AcpiGetIrqRoutingTable(Device: ACPI_HANDLE,
5186 RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
5187 pub fn AcpiResourceToAddress64(Resource: *mut ACPI_RESOURCE,
5188 Out: *mut ACPI_RESOURCE_ADDRESS64)
5189 -> ACPI_STATUS;
5190 pub fn AcpiBufferToResource(AmlBuffer: *mut UINT8,
5191 AmlBufferLength: UINT16,
5192 ResourcePtr: *mut *mut ACPI_RESOURCE)
5193 -> ACPI_STATUS;
5194 pub fn AcpiReset() -> ACPI_STATUS;
5195 pub fn AcpiRead(Value: *mut UINT64, Reg: *mut ACPI_GENERIC_ADDRESS)
5196 -> ACPI_STATUS;
5197 pub fn AcpiWrite(Value: UINT64, Reg: *mut ACPI_GENERIC_ADDRESS)
5198 -> ACPI_STATUS;
5199 pub fn AcpiReadBitRegister(RegisterId: UINT32, ReturnValue: *mut UINT32)
5200 -> ACPI_STATUS;
5201 pub fn AcpiWriteBitRegister(RegisterId: UINT32, Value: UINT32)
5202 -> ACPI_STATUS;
5203 pub fn AcpiGetSleepTypeData(SleepState: UINT8, Slp_TypA: *mut UINT8,
5204 Slp_TypB: *mut UINT8) -> ACPI_STATUS;
5205 pub fn AcpiEnterSleepStatePrep(SleepState: UINT8) -> ACPI_STATUS;
5206 pub fn AcpiEnterSleepState(SleepState: UINT8) -> ACPI_STATUS;
5207 pub fn AcpiEnterSleepStateS4bios() -> ACPI_STATUS;
5208 pub fn AcpiLeaveSleepStatePrep(SleepState: UINT8) -> ACPI_STATUS;
5209 pub fn AcpiLeaveSleepState(SleepState: UINT8) -> ACPI_STATUS;
5210 pub fn AcpiSetFirmwareWakingVector(PhysicalAddress: ACPI_PHYSICAL_ADDRESS,
5211 PhysicalAddress64:
5212 ACPI_PHYSICAL_ADDRESS)
5213 -> ACPI_STATUS;
5214 pub fn AcpiGetTimerResolution(Resolution: *mut UINT32) -> ACPI_STATUS;
5215 pub fn AcpiGetTimer(Ticks: *mut UINT32) -> ACPI_STATUS;
5216 pub fn AcpiGetTimerDuration(StartTicks: UINT32, EndTicks: UINT32,
5217 TimeElapsed: *mut UINT32) -> ACPI_STATUS;
5218 pub fn AcpiError(ModuleName: *const i8,
5219 LineNumber: UINT32,
5220 Format: *const i8, ...);
5221 pub fn AcpiException(ModuleName: *const i8,
5222 LineNumber: UINT32, Status: ACPI_STATUS,
5223 Format: *const i8, ...);
5224 pub fn AcpiWarning(ModuleName: *const i8,
5225 LineNumber: UINT32,
5226 Format: *const i8, ...);
5227 pub fn AcpiInfo(Format: *const i8, ...);
5228 pub fn AcpiBiosError(ModuleName: *const i8,
5229 LineNumber: UINT32,
5230 Format: *const i8, ...);
5231 pub fn AcpiBiosWarning(ModuleName: *const i8,
5232 LineNumber: UINT32,
5233 Format: *const i8, ...);
5234 pub fn AcpiInitializeDebugger() -> ACPI_STATUS;
5235 pub fn AcpiTerminateDebugger();
5236 pub fn AcpiSetDebuggerThreadId(ThreadId: UINT64);
5237}