pub type BOOLEAN = bool;
pub type UINT8 = u8;
pub type UINT16 = u16;
pub type INT16 = i16;
pub type UINT64 = u64;
pub type INT64 = i64;
pub type UINT32 = u32;
pub type INT32 = i32;
pub type ACPI_NATIVE_INT = INT32;
pub type ACPI_SIZE = UINT32;
pub type ACPI_IO_ADDRESS = UINT64;
pub type ACPI_PHYSICAL_ADDRESS = UINT64;
pub type ACPI_STATUS = UINT32;
pub type ACPI_NAME = UINT32;
pub type ACPI_STRING = *mut i8;
pub type ACPI_HANDLE = *mut c_void;
pub type ACPI_OWNER_ID = UINT8;
pub type ACPI_INTEGER = UINT64;
pub type ACPI_OBJECT_TYPE = UINT32;
pub type ACPI_EVENT_TYPE = UINT32;
pub type ACPI_EVENT_STATUS = UINT32;
pub type ACPI_ADR_SPACE_TYPE = UINT8;
pub type ACPI_SLEEP_FUNCTION =
::core::option::Option<extern "C" fn(SleepState: UINT8) -> ACPI_STATUS>;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_sleep_functions {
pub LegacyFunction: ACPI_SLEEP_FUNCTION,
pub ExtendedFunction: ACPI_SLEEP_FUNCTION,
}
impl ::core::clone::Clone for Struct_acpi_sleep_functions {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_sleep_functions {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SLEEP_FUNCTIONS = Struct_acpi_sleep_functions;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Union_acpi_object {
pub _bindgen_data_: [u64; 3usize],
}
impl Union_acpi_object {
pub unsafe fn Type(&mut self) -> *mut ACPI_OBJECT_TYPE {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Integer(&mut self) -> *mut Struct_Unnamed1 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn String(&mut self) -> *mut Struct_Unnamed2 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Buffer(&mut self) -> *mut Struct_Unnamed3 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Package(&mut self) -> *mut Struct_Unnamed4 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Reference(&mut self) -> *mut Struct_Unnamed5 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Processor(&mut self) -> *mut Struct_Unnamed6 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn PowerResource(&mut self) -> *mut Struct_Unnamed7 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::clone::Clone for Union_acpi_object {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Union_acpi_object {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed1 {
pub Type: ACPI_OBJECT_TYPE,
pub Value: UINT64,
}
impl ::core::clone::Clone for Struct_Unnamed1 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed1 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed2 {
pub Type: ACPI_OBJECT_TYPE,
pub Length: UINT32,
pub Pointer: *mut i8,
}
impl ::core::clone::Clone for Struct_Unnamed2 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed2 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed3 {
pub Type: ACPI_OBJECT_TYPE,
pub Length: UINT32,
pub Pointer: *mut UINT8,
}
impl ::core::clone::Clone for Struct_Unnamed3 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed3 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed4 {
pub Type: ACPI_OBJECT_TYPE,
pub Count: UINT32,
pub Elements: *mut Union_acpi_object,
}
impl ::core::clone::Clone for Struct_Unnamed4 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed4 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed5 {
pub Type: ACPI_OBJECT_TYPE,
pub ActualType: ACPI_OBJECT_TYPE,
pub Handle: ACPI_HANDLE,
}
impl ::core::clone::Clone for Struct_Unnamed5 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed5 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed6 {
pub Type: ACPI_OBJECT_TYPE,
pub ProcId: UINT32,
pub PblkAddress: ACPI_IO_ADDRESS,
pub PblkLength: UINT32,
}
impl ::core::clone::Clone for Struct_Unnamed6 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed6 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_Unnamed7 {
pub Type: ACPI_OBJECT_TYPE,
pub SystemLevel: UINT32,
pub ResourceOrder: UINT32,
}
impl ::core::clone::Clone for Struct_Unnamed7 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_Unnamed7 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_OBJECT = Union_acpi_object;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_object_list {
pub Count: UINT32,
pub Pointer: *mut ACPI_OBJECT,
}
impl ::core::clone::Clone for Struct_acpi_object_list {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_object_list {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_OBJECT_LIST = Struct_acpi_object_list;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_buffer {
pub Length: ACPI_SIZE,
pub Pointer: *mut c_void,
}
impl ::core::clone::Clone for Struct_acpi_buffer {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_buffer {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_BUFFER = Struct_acpi_buffer;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_predefined_names {
pub Name: *mut i8,
pub Type: UINT8,
pub Val: *mut i8,
}
impl ::core::clone::Clone for Struct_acpi_predefined_names {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_predefined_names {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PREDEFINED_NAMES = Struct_acpi_predefined_names;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_system_info {
pub AcpiCaVersion: UINT32,
pub Flags: UINT32,
pub TimerResolution: UINT32,
pub Reserved1: UINT32,
pub Reserved2: UINT32,
pub DebugLevel: UINT32,
pub DebugLayer: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_system_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_system_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SYSTEM_INFO = Struct_acpi_system_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_statistics {
pub SciCount: UINT32,
pub GpeCount: UINT32,
pub FixedEventCount: [UINT32; 5usize],
pub MethodCount: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_statistics {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_statistics {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_STATISTICS = Struct_acpi_statistics;
pub type ACPI_OSD_HANDLER =
::core::option::Option<unsafe extern "C" fn(Context:
*mut c_void)
-> UINT32>;
pub type ACPI_OSD_EXEC_CALLBACK =
::core::option::Option<unsafe extern "C" fn(Context:
*mut c_void)>;
pub type ACPI_SCI_HANDLER =
::core::option::Option<unsafe extern "C" fn(Context:
*mut c_void)
-> UINT32>;
pub type ACPI_GBL_EVENT_HANDLER =
::core::option::Option<unsafe extern "C" fn(EventType: UINT32,
Device: ACPI_HANDLE,
EventNumber: UINT32,
Context:
*mut c_void)>;
pub type ACPI_EVENT_HANDLER =
::core::option::Option<unsafe extern "C" fn(Context:
*mut c_void)
-> UINT32>;
pub type ACPI_GPE_HANDLER =
::core::option::Option<unsafe extern "C" fn(GpeDevice: ACPI_HANDLE,
GpeNumber: UINT32,
Context:
*mut c_void)
-> UINT32>;
pub type ACPI_NOTIFY_HANDLER =
::core::option::Option<unsafe extern "C" fn(Device: ACPI_HANDLE,
Value: UINT32,
Context:
*mut c_void)>;
pub type ACPI_OBJECT_HANDLER =
::core::option::Option<unsafe extern "C" fn(Object: ACPI_HANDLE,
Data:
*mut c_void)>;
pub type ACPI_INIT_HANDLER =
::core::option::Option<extern "C" fn(Object: ACPI_HANDLE, Function: UINT32)
-> ACPI_STATUS>;
pub type ACPI_EXCEPTION_HANDLER =
::core::option::Option<unsafe extern "C" fn(AmlStatus: ACPI_STATUS,
Name: ACPI_NAME,
Opcode: UINT16,
AmlOffset: UINT32,
Context:
*mut c_void)
-> ACPI_STATUS>;
pub type ACPI_TABLE_HANDLER =
::core::option::Option<unsafe extern "C" fn(Event: UINT32,
Table:
*mut c_void,
Context:
*mut c_void)
-> ACPI_STATUS>;
pub type ACPI_ADR_SPACE_HANDLER =
::core::option::Option<unsafe extern "C" fn(Function: UINT32,
Address: ACPI_PHYSICAL_ADDRESS,
BitWidth: UINT32,
Value: *mut UINT64,
HandlerContext:
*mut c_void,
RegionContext:
*mut c_void)
-> ACPI_STATUS>;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_connection_info {
pub Connection: *mut UINT8,
pub Length: UINT16,
pub AccessLength: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_connection_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_connection_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_CONNECTION_INFO = Struct_acpi_connection_info;
pub type ACPI_ADR_SPACE_SETUP =
::core::option::Option<unsafe extern "C" fn(RegionHandle: ACPI_HANDLE,
Function: UINT32,
HandlerContext:
*mut c_void,
RegionContext:
*mut *mut c_void)
-> ACPI_STATUS>;
pub type ACPI_WALK_CALLBACK =
::core::option::Option<unsafe extern "C" fn(Object: ACPI_HANDLE,
NestingLevel: UINT32,
Context:
*mut c_void,
ReturnValue:
*mut *mut c_void)
-> ACPI_STATUS>;
pub type ACPI_INTERFACE_HANDLER =
::core::option::Option<extern "C" fn(InterfaceName: ACPI_STRING,
Supported: UINT32) -> UINT32>;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pnp_device_id {
pub Length: UINT32,
pub String: *mut i8,
}
impl ::core::clone::Clone for Struct_acpi_pnp_device_id {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pnp_device_id {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PNP_DEVICE_ID = Struct_acpi_pnp_device_id;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pnp_device_id_list {
pub Count: UINT32,
pub ListSize: UINT32,
pub Ids: [ACPI_PNP_DEVICE_ID; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_pnp_device_id_list {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pnp_device_id_list {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PNP_DEVICE_ID_LIST = Struct_acpi_pnp_device_id_list;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_device_info {
pub InfoSize: UINT32,
pub Name: UINT32,
pub Type: ACPI_OBJECT_TYPE,
pub ParamCount: UINT8,
pub Valid: UINT16,
pub Flags: UINT8,
pub HighestDstates: [UINT8; 4usize],
pub LowestDstates: [UINT8; 5usize],
pub CurrentStatus: UINT32,
pub Address: UINT64,
pub HardwareId: ACPI_PNP_DEVICE_ID,
pub UniqueId: ACPI_PNP_DEVICE_ID,
pub ClassCode: ACPI_PNP_DEVICE_ID,
pub CompatibleIdList: ACPI_PNP_DEVICE_ID_LIST,
}
impl ::core::clone::Clone for Struct_acpi_device_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_device_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DEVICE_INFO = Struct_acpi_device_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pci_id {
pub Segment: UINT16,
pub Bus: UINT16,
pub Device: UINT16,
pub Function: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pci_id {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pci_id {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PCI_ID = Struct_acpi_pci_id;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mem_space_context {
pub Length: UINT32,
pub Address: ACPI_PHYSICAL_ADDRESS,
pub MappedPhysicalAddress: ACPI_PHYSICAL_ADDRESS,
pub MappedLogicalAddress: *mut UINT8,
pub MappedLength: ACPI_SIZE,
}
impl ::core::clone::Clone for Struct_acpi_mem_space_context {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mem_space_context {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MEM_SPACE_CONTEXT = Struct_acpi_mem_space_context;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_memory_list {
pub ListName: *mut i8,
pub ListHead: *mut c_void,
pub ObjectSize: UINT16,
pub MaxDepth: UINT16,
pub CurrentDepth: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_memory_list {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_memory_list {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MEMORY_LIST = Struct_acpi_memory_list;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed8 {
ACPI_TRACE_AML_METHOD = 0,
ACPI_TRACE_AML_OPCODE = 1,
ACPI_TRACE_AML_REGION = 2,
}
pub type ACPI_TRACE_EVENT_TYPE = Enum_Unnamed8;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_exception_info {
pub Name: *mut i8,
}
impl ::core::clone::Clone for Struct_acpi_exception_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_exception_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_EXCEPTION_INFO = Struct_acpi_exception_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_header {
pub Signature: [i8; 4usize],
pub Length: UINT32,
pub Revision: UINT8,
pub Checksum: UINT8,
pub OemId: [i8; 6usize],
pub OemTableId: [i8; 8usize],
pub OemRevision: UINT32,
pub AslCompilerId: [i8; 4usize],
pub AslCompilerRevision: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_HEADER = Struct_acpi_table_header;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_generic_address {
pub SpaceId: UINT8,
pub BitWidth: UINT8,
pub BitOffset: UINT8,
pub AccessWidth: UINT8,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_generic_address {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_generic_address {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GENERIC_ADDRESS = Struct_acpi_generic_address;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_rsdp {
pub Signature: [i8; 8usize],
pub Checksum: UINT8,
pub OemId: [i8; 6usize],
pub Revision: UINT8,
pub RsdtPhysicalAddress: UINT32,
pub Length: UINT32,
pub XsdtPhysicalAddress: UINT64,
pub ExtendedChecksum: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_table_rsdp {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_rsdp {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_RSDP = Struct_acpi_table_rsdp;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_rsdp_common {
pub Signature: [i8; 8usize],
pub Checksum: UINT8,
pub OemId: [i8; 6usize],
pub Revision: UINT8,
pub RsdtPhysicalAddress: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_rsdp_common {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_rsdp_common {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RSDP_COMMON = Struct_acpi_rsdp_common;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_rsdp_extension {
pub Length: UINT32,
pub XsdtPhysicalAddress: UINT64,
pub ExtendedChecksum: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_rsdp_extension {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_rsdp_extension {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RSDP_EXTENSION = Struct_acpi_rsdp_extension;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_rsdt {
pub Header: ACPI_TABLE_HEADER,
pub TableOffsetEntry: [UINT32; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_table_rsdt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_rsdt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_RSDT = Struct_acpi_table_rsdt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_xsdt {
pub Header: ACPI_TABLE_HEADER,
pub TableOffsetEntry: [UINT64; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_table_xsdt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_xsdt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_XSDT = Struct_acpi_table_xsdt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_facs {
pub Signature: [i8; 4usize],
pub Length: UINT32,
pub HardwareSignature: UINT32,
pub FirmwareWakingVector: UINT32,
pub GlobalLock: UINT32,
pub Flags: UINT32,
pub XFirmwareWakingVector: UINT64,
pub Version: UINT8,
pub Reserved: [UINT8; 3usize],
pub OspmFlags: UINT32,
pub Reserved1: [UINT8; 24usize],
}
impl ::core::clone::Clone for Struct_acpi_table_facs {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_facs {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_FACS = Struct_acpi_table_facs;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_fadt {
pub Header: ACPI_TABLE_HEADER,
pub Facs: UINT32,
pub Dsdt: UINT32,
pub Model: UINT8,
pub PreferredProfile: UINT8,
pub SciInterrupt: UINT16,
pub SmiCommand: UINT32,
pub AcpiEnable: UINT8,
pub AcpiDisable: UINT8,
pub S4BiosRequest: UINT8,
pub PstateControl: UINT8,
pub Pm1aEventBlock: UINT32,
pub Pm1bEventBlock: UINT32,
pub Pm1aControlBlock: UINT32,
pub Pm1bControlBlock: UINT32,
pub Pm2ControlBlock: UINT32,
pub PmTimerBlock: UINT32,
pub Gpe0Block: UINT32,
pub Gpe1Block: UINT32,
pub Pm1EventLength: UINT8,
pub Pm1ControlLength: UINT8,
pub Pm2ControlLength: UINT8,
pub PmTimerLength: UINT8,
pub Gpe0BlockLength: UINT8,
pub Gpe1BlockLength: UINT8,
pub Gpe1Base: UINT8,
pub CstControl: UINT8,
pub C2Latency: UINT16,
pub C3Latency: UINT16,
pub FlushSize: UINT16,
pub FlushStride: UINT16,
pub DutyOffset: UINT8,
pub DutyWidth: UINT8,
pub DayAlarm: UINT8,
pub MonthAlarm: UINT8,
pub Century: UINT8,
pub BootFlags: UINT16,
pub Reserved: UINT8,
pub Flags: UINT32,
pub ResetRegister: ACPI_GENERIC_ADDRESS,
pub ResetValue: UINT8,
pub ArmBootFlags: UINT16,
pub MinorRevision: UINT8,
pub XFacs: UINT64,
pub XDsdt: UINT64,
pub XPm1aEventBlock: ACPI_GENERIC_ADDRESS,
pub XPm1bEventBlock: ACPI_GENERIC_ADDRESS,
pub XPm1aControlBlock: ACPI_GENERIC_ADDRESS,
pub XPm1bControlBlock: ACPI_GENERIC_ADDRESS,
pub XPm2ControlBlock: ACPI_GENERIC_ADDRESS,
pub XPmTimerBlock: ACPI_GENERIC_ADDRESS,
pub XGpe0Block: ACPI_GENERIC_ADDRESS,
pub XGpe1Block: ACPI_GENERIC_ADDRESS,
pub SleepControl: ACPI_GENERIC_ADDRESS,
pub SleepStatus: ACPI_GENERIC_ADDRESS,
pub HypervisorId: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_fadt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_fadt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_FADT = Struct_acpi_table_fadt;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiPreferredPmProfiles {
PM_UNSPECIFIED = 0,
PM_DESKTOP = 1,
PM_MOBILE = 2,
PM_WORKSTATION = 3,
PM_ENTERPRISE_SERVER = 4,
PM_SOHO_SERVER = 5,
PM_APPLIANCE_PC = 6,
PM_PERFORMANCE_SERVER = 7,
PM_TABLET = 8,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Union_acpi_name_union {
pub _bindgen_data_: [u32; 1usize],
}
impl Union_acpi_name_union {
pub unsafe fn Integer(&mut self) -> *mut UINT32 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Ascii(&mut self) -> *mut [i8; 4usize] {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::clone::Clone for Union_acpi_name_union {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Union_acpi_name_union {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NAME_UNION = Union_acpi_name_union;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_desc {
pub Address: ACPI_PHYSICAL_ADDRESS,
pub Pointer: *mut ACPI_TABLE_HEADER,
pub Length: UINT32,
pub Signature: ACPI_NAME_UNION,
pub OwnerId: ACPI_OWNER_ID,
pub Flags: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_desc {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_desc {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_DESC = Struct_acpi_table_desc;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_subtable_header {
pub Type: UINT8,
pub Length: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_subtable_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_subtable_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SUBTABLE_HEADER = Struct_acpi_subtable_header;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_whea_header {
pub Action: UINT8,
pub Instruction: UINT8,
pub Flags: UINT8,
pub Reserved: UINT8,
pub RegisterRegion: ACPI_GENERIC_ADDRESS,
pub Value: UINT64,
pub Mask: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_whea_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_whea_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_WHEA_HEADER = Struct_acpi_whea_header;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_bert {
pub Header: ACPI_TABLE_HEADER,
pub RegionLength: UINT32,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_bert {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_bert {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_BERT = Struct_acpi_table_bert;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_bert_region {
pub BlockStatus: UINT32,
pub RawDataOffset: UINT32,
pub RawDataLength: UINT32,
pub DataLength: UINT32,
pub ErrorSeverity: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_bert_region {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_bert_region {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_BERT_REGION = Struct_acpi_bert_region;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiBertErrorSeverity {
ACPI_BERT_ERROR_CORRECTABLE = 0,
ACPI_BERT_ERROR_FATAL = 1,
ACPI_BERT_ERROR_CORRECTED = 2,
ACPI_BERT_ERROR_NONE = 3,
ACPI_BERT_ERROR_RESERVED = 4,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_cpep {
pub Header: ACPI_TABLE_HEADER,
pub Reserved: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_cpep {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_cpep {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_CPEP = Struct_acpi_table_cpep;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_cpep_polling {
pub Header: ACPI_SUBTABLE_HEADER,
pub Id: UINT8,
pub Eid: UINT8,
pub Interval: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_cpep_polling {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_cpep_polling {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_CPEP_POLLING = Struct_acpi_cpep_polling;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_ecdt {
pub Header: ACPI_TABLE_HEADER,
pub Control: ACPI_GENERIC_ADDRESS,
pub Data: ACPI_GENERIC_ADDRESS,
pub Uid: UINT32,
pub Gpe: UINT8,
pub Id: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_table_ecdt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_ecdt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_ECDT = Struct_acpi_table_ecdt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_einj {
pub Header: ACPI_TABLE_HEADER,
pub HeaderLength: UINT32,
pub Flags: UINT8,
pub Reserved: [UINT8; 3usize],
pub Entries: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_einj {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_einj {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_EINJ = Struct_acpi_table_einj;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_einj_entry {
pub WheaHeader: ACPI_WHEA_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_einj_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_einj_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_EINJ_ENTRY = Struct_acpi_einj_entry;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiEinjActions {
ACPI_EINJ_BEGIN_OPERATION = 0,
ACPI_EINJ_GET_TRIGGER_TABLE = 1,
ACPI_EINJ_SET_ERROR_TYPE = 2,
ACPI_EINJ_GET_ERROR_TYPE = 3,
ACPI_EINJ_END_OPERATION = 4,
ACPI_EINJ_EXECUTE_OPERATION = 5,
ACPI_EINJ_CHECK_BUSY_STATUS = 6,
ACPI_EINJ_GET_COMMAND_STATUS = 7,
ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS = 8,
ACPI_EINJ_GET_EXECUTE_TIMINGS = 9,
ACPI_EINJ_ACTION_RESERVED = 10,
ACPI_EINJ_TRIGGER_ERROR = 255,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiEinjInstructions {
ACPI_EINJ_READ_REGISTER = 0,
ACPI_EINJ_READ_REGISTER_VALUE = 1,
ACPI_EINJ_WRITE_REGISTER = 2,
ACPI_EINJ_WRITE_REGISTER_VALUE = 3,
ACPI_EINJ_NOOP = 4,
ACPI_EINJ_FLUSH_CACHELINE = 5,
ACPI_EINJ_INSTRUCTION_RESERVED = 6,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_einj_error_type_with_addr {
pub ErrorType: UINT32,
pub VendorStructOffset: UINT32,
pub Flags: UINT32,
pub ApicId: UINT32,
pub Address: UINT64,
pub Range: UINT64,
pub PcieId: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_einj_error_type_with_addr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_einj_error_type_with_addr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_EINJ_ERROR_TYPE_WITH_ADDR =
Struct_acpi_einj_error_type_with_addr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_einj_vendor {
pub Length: UINT32,
pub PcieId: UINT32,
pub VendorId: UINT16,
pub DeviceId: UINT16,
pub RevisionId: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_einj_vendor {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_einj_vendor {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_EINJ_VENDOR = Struct_acpi_einj_vendor;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_einj_trigger {
pub HeaderSize: UINT32,
pub Revision: UINT32,
pub TableSize: UINT32,
pub EntryCount: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_einj_trigger {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_einj_trigger {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_EINJ_TRIGGER = Struct_acpi_einj_trigger;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiEinjCommandStatus {
ACPI_EINJ_SUCCESS = 0,
ACPI_EINJ_FAILURE = 1,
ACPI_EINJ_INVALID_ACCESS = 2,
ACPI_EINJ_STATUS_RESERVED = 3,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_erst {
pub Header: ACPI_TABLE_HEADER,
pub HeaderLength: UINT32,
pub Reserved: UINT32,
pub Entries: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_erst {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_erst {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_ERST = Struct_acpi_table_erst;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_erst_entry {
pub WheaHeader: ACPI_WHEA_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_erst_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_erst_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ERST_ENTRY = Struct_acpi_erst_entry;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiErstActions {
ACPI_ERST_BEGIN_WRITE = 0,
ACPI_ERST_BEGIN_READ = 1,
ACPI_ERST_BEGIN_CLEAR = 2,
ACPI_ERST_END = 3,
ACPI_ERST_SET_RECORD_OFFSET = 4,
ACPI_ERST_EXECUTE_OPERATION = 5,
ACPI_ERST_CHECK_BUSY_STATUS = 6,
ACPI_ERST_GET_COMMAND_STATUS = 7,
ACPI_ERST_GET_RECORD_ID = 8,
ACPI_ERST_SET_RECORD_ID = 9,
ACPI_ERST_GET_RECORD_COUNT = 10,
ACPI_ERST_BEGIN_DUMMY_WRIITE = 11,
ACPI_ERST_NOT_USED = 12,
ACPI_ERST_GET_ERROR_RANGE = 13,
ACPI_ERST_GET_ERROR_LENGTH = 14,
ACPI_ERST_GET_ERROR_ATTRIBUTES = 15,
ACPI_ERST_EXECUTE_TIMINGS = 16,
ACPI_ERST_ACTION_RESERVED = 17,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiErstInstructions {
ACPI_ERST_READ_REGISTER = 0,
ACPI_ERST_READ_REGISTER_VALUE = 1,
ACPI_ERST_WRITE_REGISTER = 2,
ACPI_ERST_WRITE_REGISTER_VALUE = 3,
ACPI_ERST_NOOP = 4,
ACPI_ERST_LOAD_VAR1 = 5,
ACPI_ERST_LOAD_VAR2 = 6,
ACPI_ERST_STORE_VAR1 = 7,
ACPI_ERST_ADD = 8,
ACPI_ERST_SUBTRACT = 9,
ACPI_ERST_ADD_VALUE = 10,
ACPI_ERST_SUBTRACT_VALUE = 11,
ACPI_ERST_STALL = 12,
ACPI_ERST_STALL_WHILE_TRUE = 13,
ACPI_ERST_SKIP_NEXT_IF_TRUE = 14,
ACPI_ERST_GOTO = 15,
ACPI_ERST_SET_SRC_ADDRESS_BASE = 16,
ACPI_ERST_SET_DST_ADDRESS_BASE = 17,
ACPI_ERST_MOVE_DATA = 18,
ACPI_ERST_INSTRUCTION_RESERVED = 19,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiErstCommandStatus {
ACPI_ERST_SUCESS = 0,
ACPI_ERST_NO_SPACE = 1,
ACPI_ERST_NOT_AVAILABLE = 2,
ACPI_ERST_FAILURE = 3,
ACPI_ERST_RECORD_EMPTY = 4,
ACPI_ERST_NOT_FOUND = 5,
ACPI_ERST_STATUS_RESERVED = 6,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_erst_info {
pub Signature: UINT16,
pub Data: [UINT8; 48usize],
}
impl ::core::clone::Clone for Struct_acpi_erst_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_erst_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ERST_INFO = Struct_acpi_erst_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_hest {
pub Header: ACPI_TABLE_HEADER,
pub ErrorSourceCount: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_hest {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_hest {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_HEST = Struct_acpi_table_hest;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_header {
pub Type: UINT16,
pub SourceId: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_hest_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_HEADER = Struct_acpi_hest_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiHestTypes {
ACPI_HEST_TYPE_IA32_CHECK = 0,
ACPI_HEST_TYPE_IA32_CORRECTED_CHECK = 1,
ACPI_HEST_TYPE_IA32_NMI = 2,
ACPI_HEST_TYPE_NOT_USED3 = 3,
ACPI_HEST_TYPE_NOT_USED4 = 4,
ACPI_HEST_TYPE_NOT_USED5 = 5,
ACPI_HEST_TYPE_AER_ROOT_PORT = 6,
ACPI_HEST_TYPE_AER_ENDPOINT = 7,
ACPI_HEST_TYPE_AER_BRIDGE = 8,
ACPI_HEST_TYPE_GENERIC_ERROR = 9,
ACPI_HEST_TYPE_GENERIC_ERROR_V2 = 10,
ACPI_HEST_TYPE_RESERVED = 11,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_ia_error_bank {
pub BankNumber: UINT8,
pub ClearStatusOnInit: UINT8,
pub StatusFormat: UINT8,
pub Reserved: UINT8,
pub ControlRegister: UINT32,
pub ControlData: UINT64,
pub StatusRegister: UINT32,
pub AddressRegister: UINT32,
pub MiscRegister: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_ia_error_bank {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_ia_error_bank {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_IA_ERROR_BANK = Struct_acpi_hest_ia_error_bank;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_aer_common {
pub Reserved1: UINT16,
pub Flags: UINT8,
pub Enabled: UINT8,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub Bus: UINT32,
pub Device: UINT16,
pub Function: UINT16,
pub DeviceControl: UINT16,
pub Reserved2: UINT16,
pub UncorrectableMask: UINT32,
pub UncorrectableSeverity: UINT32,
pub CorrectableMask: UINT32,
pub AdvancedCapabilities: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_aer_common {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_aer_common {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_AER_COMMON = Struct_acpi_hest_aer_common;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_notify {
pub Type: UINT8,
pub Length: UINT8,
pub ConfigWriteEnable: UINT16,
pub PollInterval: UINT32,
pub Vector: UINT32,
pub PollingThresholdValue: UINT32,
pub PollingThresholdWindow: UINT32,
pub ErrorThresholdValue: UINT32,
pub ErrorThresholdWindow: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_notify {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_notify {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_NOTIFY = Struct_acpi_hest_notify;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiHestNotifyTypes {
ACPI_HEST_NOTIFY_POLLED = 0,
ACPI_HEST_NOTIFY_EXTERNAL = 1,
ACPI_HEST_NOTIFY_LOCAL = 2,
ACPI_HEST_NOTIFY_SCI = 3,
ACPI_HEST_NOTIFY_NMI = 4,
ACPI_HEST_NOTIFY_CMCI = 5,
ACPI_HEST_NOTIFY_MCE = 6,
ACPI_HEST_NOTIFY_RESERVED = 7,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_ia_machine_check {
pub Header: ACPI_HEST_HEADER,
pub Reserved1: UINT16,
pub Flags: UINT8,
pub Enabled: UINT8,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub GlobalCapabilityData: UINT64,
pub GlobalControlData: UINT64,
pub NumHardwareBanks: UINT8,
pub Reserved3: [UINT8; 7usize],
}
impl ::core::clone::Clone for Struct_acpi_hest_ia_machine_check {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_ia_machine_check {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_IA_MACHINE_CHECK = Struct_acpi_hest_ia_machine_check;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_ia_corrected {
pub Header: ACPI_HEST_HEADER,
pub Reserved1: UINT16,
pub Flags: UINT8,
pub Enabled: UINT8,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub Notify: ACPI_HEST_NOTIFY,
pub NumHardwareBanks: UINT8,
pub Reserved2: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_hest_ia_corrected {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_ia_corrected {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_IA_CORRECTED = Struct_acpi_hest_ia_corrected;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_ia_nmi {
pub Header: ACPI_HEST_HEADER,
pub Reserved: UINT32,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub MaxRawDataLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_ia_nmi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_ia_nmi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_IA_NMI = Struct_acpi_hest_ia_nmi;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_aer_root {
pub Header: ACPI_HEST_HEADER,
pub Aer: ACPI_HEST_AER_COMMON,
pub RootErrorCommand: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_aer_root {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_aer_root {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_AER_ROOT = Struct_acpi_hest_aer_root;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_aer {
pub Header: ACPI_HEST_HEADER,
pub Aer: ACPI_HEST_AER_COMMON,
}
impl ::core::clone::Clone for Struct_acpi_hest_aer {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_aer {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_AER = Struct_acpi_hest_aer;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_aer_bridge {
pub Header: ACPI_HEST_HEADER,
pub Aer: ACPI_HEST_AER_COMMON,
pub UncorrectableMask2: UINT32,
pub UncorrectableSeverity2: UINT32,
pub AdvancedCapabilities2: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_aer_bridge {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_aer_bridge {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_AER_BRIDGE = Struct_acpi_hest_aer_bridge;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_generic {
pub Header: ACPI_HEST_HEADER,
pub RelatedSourceId: UINT16,
pub Reserved: UINT8,
pub Enabled: UINT8,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub MaxRawDataLength: UINT32,
pub ErrorStatusAddress: ACPI_GENERIC_ADDRESS,
pub Notify: ACPI_HEST_NOTIFY,
pub ErrorBlockLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_generic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_generic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_GENERIC = Struct_acpi_hest_generic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_generic_v2 {
pub Header: ACPI_HEST_HEADER,
pub RelatedSourceId: UINT16,
pub Reserved: UINT8,
pub Enabled: UINT8,
pub RecordsToPreallocate: UINT32,
pub MaxSectionsPerRecord: UINT32,
pub MaxRawDataLength: UINT32,
pub ErrorStatusAddress: ACPI_GENERIC_ADDRESS,
pub Notify: ACPI_HEST_NOTIFY,
pub ErrorBlockLength: UINT32,
pub ReadAckRegister: ACPI_GENERIC_ADDRESS,
pub ReadAckPreserve: UINT64,
pub ReadAckWrite: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_hest_generic_v2 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_generic_v2 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_GENERIC_V2 = Struct_acpi_hest_generic_v2;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_generic_status {
pub BlockStatus: UINT32,
pub RawDataOffset: UINT32,
pub RawDataLength: UINT32,
pub DataLength: UINT32,
pub ErrorSeverity: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_hest_generic_status {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_generic_status {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_GENERIC_STATUS = Struct_acpi_hest_generic_status;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_hest_generic_data {
pub SectionType: [UINT8; 16usize],
pub ErrorSeverity: UINT32,
pub Revision: UINT16,
pub ValidationBits: UINT8,
pub Flags: UINT8,
pub ErrorDataLength: UINT32,
pub FruId: [UINT8; 16usize],
pub FruText: [UINT8; 20usize],
pub TimeStamp: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_hest_generic_data {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_hest_generic_data {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_HEST_GENERIC_DATA = Struct_acpi_hest_generic_data;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_madt {
pub Header: ACPI_TABLE_HEADER,
pub Address: UINT32,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_madt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_madt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MADT = Struct_acpi_table_madt;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiMadtType {
ACPI_MADT_TYPE_LOCAL_APIC = 0,
ACPI_MADT_TYPE_IO_APIC = 1,
ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2,
ACPI_MADT_TYPE_NMI_SOURCE = 3,
ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4,
ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5,
ACPI_MADT_TYPE_IO_SAPIC = 6,
ACPI_MADT_TYPE_LOCAL_SAPIC = 7,
ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8,
ACPI_MADT_TYPE_LOCAL_X2APIC = 9,
ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10,
ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11,
ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12,
ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13,
ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14,
ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15,
ACPI_MADT_TYPE_RESERVED = 16,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_apic {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProcessorId: UINT8,
pub Id: UINT8,
pub LapicFlags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_local_apic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_apic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_APIC = Struct_acpi_madt_local_apic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_io_apic {
pub Header: ACPI_SUBTABLE_HEADER,
pub Id: UINT8,
pub Reserved: UINT8,
pub Address: UINT32,
pub GlobalIrqBase: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_io_apic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_io_apic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_IO_APIC = Struct_acpi_madt_io_apic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_interrupt_override {
pub Header: ACPI_SUBTABLE_HEADER,
pub Bus: UINT8,
pub SourceIrq: UINT8,
pub GlobalIrq: UINT32,
pub IntiFlags: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_madt_interrupt_override {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_interrupt_override {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_INTERRUPT_OVERRIDE = Struct_acpi_madt_interrupt_override;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_nmi_source {
pub Header: ACPI_SUBTABLE_HEADER,
pub IntiFlags: UINT16,
pub GlobalIrq: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_nmi_source {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_nmi_source {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_NMI_SOURCE = Struct_acpi_madt_nmi_source;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_apic_nmi {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProcessorId: UINT8,
pub IntiFlags: UINT16,
pub Lint: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_madt_local_apic_nmi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_apic_nmi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_APIC_NMI = Struct_acpi_madt_local_apic_nmi;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_apic_override {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_madt_local_apic_override {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_apic_override {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_APIC_OVERRIDE = Struct_acpi_madt_local_apic_override;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_io_sapic {
pub Header: ACPI_SUBTABLE_HEADER,
pub Id: UINT8,
pub Reserved: UINT8,
pub GlobalIrqBase: UINT32,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_madt_io_sapic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_io_sapic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_IO_SAPIC = Struct_acpi_madt_io_sapic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_sapic {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProcessorId: UINT8,
pub Id: UINT8,
pub Eid: UINT8,
pub Reserved: [UINT8; 3usize],
pub LapicFlags: UINT32,
pub Uid: UINT32,
pub UidString: [i8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_madt_local_sapic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_sapic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_SAPIC = Struct_acpi_madt_local_sapic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_interrupt_source {
pub Header: ACPI_SUBTABLE_HEADER,
pub IntiFlags: UINT16,
pub Type: UINT8,
pub Id: UINT8,
pub Eid: UINT8,
pub IoSapicVector: UINT8,
pub GlobalIrq: UINT32,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_interrupt_source {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_interrupt_source {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_INTERRUPT_SOURCE = Struct_acpi_madt_interrupt_source;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_x2apic {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub LocalApicId: UINT32,
pub LapicFlags: UINT32,
pub Uid: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_local_x2apic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_x2apic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_X2APIC = Struct_acpi_madt_local_x2apic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_local_x2apic_nmi {
pub Header: ACPI_SUBTABLE_HEADER,
pub IntiFlags: UINT16,
pub Uid: UINT32,
pub Lint: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_madt_local_x2apic_nmi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_local_x2apic_nmi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_LOCAL_X2APIC_NMI = Struct_acpi_madt_local_x2apic_nmi;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_generic_interrupt {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub CpuInterfaceNumber: UINT32,
pub Uid: UINT32,
pub Flags: UINT32,
pub ParkingVersion: UINT32,
pub PerformanceInterrupt: UINT32,
pub ParkedAddress: UINT64,
pub BaseAddress: UINT64,
pub GicvBaseAddress: UINT64,
pub GichBaseAddress: UINT64,
pub VgicInterrupt: UINT32,
pub GicrBaseAddress: UINT64,
pub ArmMpidr: UINT64,
pub EfficiencyClass: UINT8,
pub Reserved2: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_madt_generic_interrupt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_generic_interrupt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_GENERIC_INTERRUPT = Struct_acpi_madt_generic_interrupt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_generic_distributor {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub GicId: UINT32,
pub BaseAddress: UINT64,
pub GlobalIrqBase: UINT32,
pub Version: UINT8,
pub Reserved2: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_madt_generic_distributor {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_generic_distributor {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_GENERIC_DISTRIBUTOR = Struct_acpi_madt_generic_distributor;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiMadtGicVersion {
ACPI_MADT_GIC_VERSION_NONE = 0,
ACPI_MADT_GIC_VERSION_V1 = 1,
ACPI_MADT_GIC_VERSION_V2 = 2,
ACPI_MADT_GIC_VERSION_V3 = 3,
ACPI_MADT_GIC_VERSION_V4 = 4,
ACPI_MADT_GIC_VERSION_RESERVED = 5,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_generic_msi_frame {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub MsiFrameId: UINT32,
pub BaseAddress: UINT64,
pub Flags: UINT32,
pub SpiCount: UINT16,
pub SpiBase: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_madt_generic_msi_frame {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_generic_msi_frame {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_GENERIC_MSI_FRAME = Struct_acpi_madt_generic_msi_frame;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_generic_redistributor {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub BaseAddress: UINT64,
pub Length: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_generic_redistributor {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_generic_redistributor {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_GENERIC_REDISTRIBUTOR =
Struct_acpi_madt_generic_redistributor;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_madt_generic_translator {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub TranslationId: UINT32,
pub BaseAddress: UINT64,
pub Reserved2: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_madt_generic_translator {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_madt_generic_translator {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MADT_GENERIC_TRANSLATOR = Struct_acpi_madt_generic_translator;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_msct {
pub Header: ACPI_TABLE_HEADER,
pub ProximityOffset: UINT32,
pub MaxProximityDomains: UINT32,
pub MaxClockDomains: UINT32,
pub MaxAddress: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_msct {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_msct {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MSCT = Struct_acpi_table_msct;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_msct_proximity {
pub Revision: UINT8,
pub Length: UINT8,
pub RangeStart: UINT32,
pub RangeEnd: UINT32,
pub ProcessorCapacity: UINT32,
pub MemoryCapacity: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_msct_proximity {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_msct_proximity {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MSCT_PROXIMITY = Struct_acpi_msct_proximity;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_nfit {
pub Header: ACPI_TABLE_HEADER,
pub Reserved: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_nfit {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_nfit {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_NFIT = Struct_acpi_table_nfit;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_header {
pub Type: UINT16,
pub Length: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_nfit_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_HEADER = Struct_acpi_nfit_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiNfitType {
ACPI_NFIT_TYPE_SYSTEM_ADDRESS = 0,
ACPI_NFIT_TYPE_MEMORY_MAP = 1,
ACPI_NFIT_TYPE_INTERLEAVE = 2,
ACPI_NFIT_TYPE_SMBIOS = 3,
ACPI_NFIT_TYPE_CONTROL_REGION = 4,
ACPI_NFIT_TYPE_DATA_REGION = 5,
ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6,
ACPI_NFIT_TYPE_RESERVED = 7,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_system_address {
pub Header: ACPI_NFIT_HEADER,
pub RangeIndex: UINT16,
pub Flags: UINT16,
pub Reserved: UINT32,
pub ProximityDomain: UINT32,
pub RangeGuid: [UINT8; 16usize],
pub Address: UINT64,
pub Length: UINT64,
pub MemoryMapping: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_nfit_system_address {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_system_address {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_SYSTEM_ADDRESS = Struct_acpi_nfit_system_address;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_memory_map {
pub Header: ACPI_NFIT_HEADER,
pub DeviceHandle: UINT32,
pub PhysicalId: UINT16,
pub RegionId: UINT16,
pub RangeIndex: UINT16,
pub RegionIndex: UINT16,
pub RegionSize: UINT64,
pub RegionOffset: UINT64,
pub Address: UINT64,
pub InterleaveIndex: UINT16,
pub InterleaveWays: UINT16,
pub Flags: UINT16,
pub Reserved: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_nfit_memory_map {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_memory_map {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_MEMORY_MAP = Struct_acpi_nfit_memory_map;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_interleave {
pub Header: ACPI_NFIT_HEADER,
pub InterleaveIndex: UINT16,
pub Reserved: UINT16,
pub LineCount: UINT32,
pub LineSize: UINT32,
pub LineOffset: [UINT32; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_nfit_interleave {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_interleave {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_INTERLEAVE = Struct_acpi_nfit_interleave;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_smbios {
pub Header: ACPI_NFIT_HEADER,
pub Reserved: UINT32,
pub Data: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_nfit_smbios {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_smbios {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_SMBIOS = Struct_acpi_nfit_smbios;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_control_region {
pub Header: ACPI_NFIT_HEADER,
pub RegionIndex: UINT16,
pub VendorId: UINT16,
pub DeviceId: UINT16,
pub RevisionId: UINT16,
pub SubsystemVendorId: UINT16,
pub SubsystemDeviceId: UINT16,
pub SubsystemRevisionId: UINT16,
pub Reserved: [UINT8; 6usize],
pub SerialNumber: UINT32,
pub Code: UINT16,
pub Windows: UINT16,
pub WindowSize: UINT64,
pub CommandOffset: UINT64,
pub CommandSize: UINT64,
pub StatusOffset: UINT64,
pub StatusSize: UINT64,
pub Flags: UINT16,
pub Reserved1: [UINT8; 6usize],
}
impl ::core::clone::Clone for Struct_acpi_nfit_control_region {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_control_region {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_CONTROL_REGION = Struct_acpi_nfit_control_region;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_data_region {
pub Header: ACPI_NFIT_HEADER,
pub RegionIndex: UINT16,
pub Windows: UINT16,
pub Offset: UINT64,
pub Size: UINT64,
pub Capacity: UINT64,
pub StartAddress: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_nfit_data_region {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_data_region {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_DATA_REGION = Struct_acpi_nfit_data_region;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_nfit_flush_address {
pub Header: ACPI_NFIT_HEADER,
pub DeviceHandle: UINT32,
pub HintCount: UINT16,
pub Reserved: [UINT8; 6usize],
pub HintAddress: [UINT64; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_nfit_flush_address {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_nfit_flush_address {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_NFIT_FLUSH_ADDRESS = Struct_acpi_nfit_flush_address;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_sbst {
pub Header: ACPI_TABLE_HEADER,
pub WarningLevel: UINT32,
pub LowLevel: UINT32,
pub CriticalLevel: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_sbst {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_sbst {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SBST = Struct_acpi_table_sbst;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_slit {
pub Header: ACPI_TABLE_HEADER,
pub LocalityCount: UINT64,
pub Entry: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_table_slit {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_slit {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SLIT = Struct_acpi_table_slit;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_srat {
pub Header: ACPI_TABLE_HEADER,
pub TableRevision: UINT32,
pub Reserved: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_srat {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_srat {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SRAT = Struct_acpi_table_srat;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiSratType {
ACPI_SRAT_TYPE_CPU_AFFINITY = 0,
ACPI_SRAT_TYPE_MEMORY_AFFINITY = 1,
ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY = 2,
ACPI_SRAT_TYPE_GICC_AFFINITY = 3,
ACPI_SRAT_TYPE_RESERVED = 4,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_srat_cpu_affinity {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProximityDomainLo: UINT8,
pub ApicId: UINT8,
pub Flags: UINT32,
pub LocalSapicEid: UINT8,
pub ProximityDomainHi: [UINT8; 3usize],
pub ClockDomain: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_srat_cpu_affinity {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_srat_cpu_affinity {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SRAT_CPU_AFFINITY = Struct_acpi_srat_cpu_affinity;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_srat_mem_affinity {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProximityDomain: UINT32,
pub Reserved: UINT16,
pub BaseAddress: UINT64,
pub Length: UINT64,
pub Reserved1: UINT32,
pub Flags: UINT32,
pub Reserved2: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_srat_mem_affinity {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_srat_mem_affinity {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SRAT_MEM_AFFINITY = Struct_acpi_srat_mem_affinity;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_srat_x2apic_cpu_affinity {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: UINT16,
pub ProximityDomain: UINT32,
pub ApicId: UINT32,
pub Flags: UINT32,
pub ClockDomain: UINT32,
pub Reserved2: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_srat_x2apic_cpu_affinity {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_srat_x2apic_cpu_affinity {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SRAT_X2APIC_CPU_AFFINITY = Struct_acpi_srat_x2apic_cpu_affinity;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_srat_gicc_affinity {
pub Header: ACPI_SUBTABLE_HEADER,
pub ProximityDomain: UINT32,
pub AcpiProcessorUid: UINT32,
pub Flags: UINT32,
pub ClockDomain: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_srat_gicc_affinity {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_srat_gicc_affinity {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SRAT_GICC_AFFINITY = Struct_acpi_srat_gicc_affinity;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_asf {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_asf {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_asf {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_ASF = Struct_acpi_table_asf;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_header {
pub Type: UINT8,
pub Reserved: UINT8,
pub Length: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_asf_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_HEADER = Struct_acpi_asf_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiAsfType {
ACPI_ASF_TYPE_INFO = 0,
ACPI_ASF_TYPE_ALERT = 1,
ACPI_ASF_TYPE_CONTROL = 2,
ACPI_ASF_TYPE_BOOT = 3,
ACPI_ASF_TYPE_ADDRESS = 4,
ACPI_ASF_TYPE_RESERVED = 5,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_info {
pub Header: ACPI_ASF_HEADER,
pub MinResetValue: UINT8,
pub MinPollInterval: UINT8,
pub SystemId: UINT16,
pub MfgId: UINT32,
pub Flags: UINT8,
pub Reserved2: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_asf_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_INFO = Struct_acpi_asf_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_alert {
pub Header: ACPI_ASF_HEADER,
pub AssertMask: UINT8,
pub DeassertMask: UINT8,
pub Alerts: UINT8,
pub DataLength: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_asf_alert {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_alert {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_ALERT = Struct_acpi_asf_alert;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_alert_data {
pub Address: UINT8,
pub Command: UINT8,
pub Mask: UINT8,
pub Value: UINT8,
pub SensorType: UINT8,
pub Type: UINT8,
pub Offset: UINT8,
pub SourceType: UINT8,
pub Severity: UINT8,
pub SensorNumber: UINT8,
pub Entity: UINT8,
pub Instance: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_asf_alert_data {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_alert_data {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_ALERT_DATA = Struct_acpi_asf_alert_data;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_remote {
pub Header: ACPI_ASF_HEADER,
pub Controls: UINT8,
pub DataLength: UINT8,
pub Reserved2: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_asf_remote {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_remote {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_REMOTE = Struct_acpi_asf_remote;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_control_data {
pub Function: UINT8,
pub Address: UINT8,
pub Command: UINT8,
pub Value: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_asf_control_data {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_control_data {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_CONTROL_DATA = Struct_acpi_asf_control_data;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_rmcp {
pub Header: ACPI_ASF_HEADER,
pub Capabilities: [UINT8; 7usize],
pub CompletionCode: UINT8,
pub EnterpriseId: UINT32,
pub Command: UINT8,
pub Parameter: UINT16,
pub BootOptions: UINT16,
pub OemParameters: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_asf_rmcp {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_rmcp {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_RMCP = Struct_acpi_asf_rmcp;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_asf_address {
pub Header: ACPI_ASF_HEADER,
pub EpromAddress: UINT8,
pub Devices: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_asf_address {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_asf_address {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ASF_ADDRESS = Struct_acpi_asf_address;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_boot {
pub Header: ACPI_TABLE_HEADER,
pub CmosIndex: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_table_boot {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_boot {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_BOOT = Struct_acpi_table_boot;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_csrt {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_csrt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_csrt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_CSRT = Struct_acpi_table_csrt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_csrt_group {
pub Length: UINT32,
pub VendorId: UINT32,
pub SubvendorId: UINT32,
pub DeviceId: UINT16,
pub SubdeviceId: UINT16,
pub Revision: UINT16,
pub Reserved: UINT16,
pub SharedInfoLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_csrt_group {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_csrt_group {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_CSRT_GROUP = Struct_acpi_csrt_group;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_csrt_shared_info {
pub MajorVersion: UINT16,
pub MinorVersion: UINT16,
pub MmioBaseLow: UINT32,
pub MmioBaseHigh: UINT32,
pub GsiInterrupt: UINT32,
pub InterruptPolarity: UINT8,
pub InterruptMode: UINT8,
pub NumChannels: UINT8,
pub DmaAddressWidth: UINT8,
pub BaseRequestLine: UINT16,
pub NumHandshakeSignals: UINT16,
pub MaxBlockSize: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_csrt_shared_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_csrt_shared_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_CSRT_SHARED_INFO = Struct_acpi_csrt_shared_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_csrt_descriptor {
pub Length: UINT32,
pub Type: UINT16,
pub Subtype: UINT16,
pub Uid: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_csrt_descriptor {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_csrt_descriptor {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_CSRT_DESCRIPTOR = Struct_acpi_csrt_descriptor;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_dbg2 {
pub Header: ACPI_TABLE_HEADER,
pub InfoOffset: UINT32,
pub InfoCount: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_dbg2 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_dbg2 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_DBG2 = Struct_acpi_table_dbg2;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dbg2_header {
pub InfoOffset: UINT32,
pub InfoCount: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_dbg2_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dbg2_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DBG2_HEADER = Struct_acpi_dbg2_header;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dbg2_device {
pub Revision: UINT8,
pub Length: UINT16,
pub RegisterCount: UINT8,
pub NamepathLength: UINT16,
pub NamepathOffset: UINT16,
pub OemDataLength: UINT16,
pub OemDataOffset: UINT16,
pub PortType: UINT16,
pub PortSubtype: UINT16,
pub Reserved: UINT16,
pub BaseAddressOffset: UINT16,
pub AddressSizeOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_dbg2_device {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dbg2_device {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DBG2_DEVICE = Struct_acpi_dbg2_device;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_dbgp {
pub Header: ACPI_TABLE_HEADER,
pub Type: UINT8,
pub Reserved: [UINT8; 3usize],
pub DebugPort: ACPI_GENERIC_ADDRESS,
}
impl ::core::clone::Clone for Struct_acpi_table_dbgp {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_dbgp {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_DBGP = Struct_acpi_table_dbgp;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_dmar {
pub Header: ACPI_TABLE_HEADER,
pub Width: UINT8,
pub Flags: UINT8,
pub Reserved: [UINT8; 10usize],
}
impl ::core::clone::Clone for Struct_acpi_table_dmar {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_dmar {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_DMAR = Struct_acpi_table_dmar;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_header {
pub Type: UINT16,
pub Length: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_dmar_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_HEADER = Struct_acpi_dmar_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiDmarType {
ACPI_DMAR_TYPE_HARDWARE_UNIT = 0,
ACPI_DMAR_TYPE_RESERVED_MEMORY = 1,
ACPI_DMAR_TYPE_ROOT_ATS = 2,
ACPI_DMAR_TYPE_HARDWARE_AFFINITY = 3,
ACPI_DMAR_TYPE_NAMESPACE = 4,
ACPI_DMAR_TYPE_RESERVED = 5,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_device_scope {
pub EntryType: UINT8,
pub Length: UINT8,
pub Reserved: UINT16,
pub EnumerationId: UINT8,
pub Bus: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_dmar_device_scope {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_device_scope {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_DEVICE_SCOPE = Struct_acpi_dmar_device_scope;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiDmarScopeType {
ACPI_DMAR_SCOPE_TYPE_NOT_USED = 0,
ACPI_DMAR_SCOPE_TYPE_ENDPOINT = 1,
ACPI_DMAR_SCOPE_TYPE_BRIDGE = 2,
ACPI_DMAR_SCOPE_TYPE_IOAPIC = 3,
ACPI_DMAR_SCOPE_TYPE_HPET = 4,
ACPI_DMAR_SCOPE_TYPE_NAMESPACE = 5,
ACPI_DMAR_SCOPE_TYPE_RESERVED = 6,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_pci_path {
pub Device: UINT8,
pub Function: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_dmar_pci_path {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_pci_path {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_PCI_PATH = Struct_acpi_dmar_pci_path;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_hardware_unit {
pub Header: ACPI_DMAR_HEADER,
pub Flags: UINT8,
pub Reserved: UINT8,
pub Segment: UINT16,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_dmar_hardware_unit {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_hardware_unit {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_HARDWARE_UNIT = Struct_acpi_dmar_hardware_unit;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_reserved_memory {
pub Header: ACPI_DMAR_HEADER,
pub Reserved: UINT16,
pub Segment: UINT16,
pub BaseAddress: UINT64,
pub EndAddress: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_dmar_reserved_memory {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_reserved_memory {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_RESERVED_MEMORY = Struct_acpi_dmar_reserved_memory;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_atsr {
pub Header: ACPI_DMAR_HEADER,
pub Flags: UINT8,
pub Reserved: UINT8,
pub Segment: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_dmar_atsr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_atsr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_ATSR = Struct_acpi_dmar_atsr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_rhsa {
pub Header: ACPI_DMAR_HEADER,
pub Reserved: UINT32,
pub BaseAddress: UINT64,
pub ProximityDomain: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_dmar_rhsa {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_rhsa {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_RHSA = Struct_acpi_dmar_rhsa;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_dmar_andd {
pub Header: ACPI_DMAR_HEADER,
pub Reserved: [UINT8; 3usize],
pub DeviceNumber: UINT8,
pub DeviceName: [i8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_dmar_andd {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_dmar_andd {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DMAR_ANDD = Struct_acpi_dmar_andd;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_hpet {
pub Header: ACPI_TABLE_HEADER,
pub Id: UINT32,
pub Address: ACPI_GENERIC_ADDRESS,
pub Sequence: UINT8,
pub MinimumTick: UINT16,
pub Flags: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_hpet {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_hpet {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_HPET = Struct_acpi_table_hpet;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiHpetPageProtect {
ACPI_HPET_NO_PAGE_PROTECT = 0,
ACPI_HPET_PAGE_PROTECT4 = 1,
ACPI_HPET_PAGE_PROTECT64 = 2,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_ibft {
pub Header: ACPI_TABLE_HEADER,
pub Reserved: [UINT8; 12usize],
}
impl ::core::clone::Clone for Struct_acpi_table_ibft {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_ibft {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_IBFT = Struct_acpi_table_ibft;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ibft_header {
pub Type: UINT8,
pub Version: UINT8,
pub Length: UINT16,
pub Index: UINT8,
pub Flags: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_ibft_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ibft_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IBFT_HEADER = Struct_acpi_ibft_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiIbftType {
ACPI_IBFT_TYPE_NOT_USED = 0,
ACPI_IBFT_TYPE_CONTROL = 1,
ACPI_IBFT_TYPE_INITIATOR = 2,
ACPI_IBFT_TYPE_NIC = 3,
ACPI_IBFT_TYPE_TARGET = 4,
ACPI_IBFT_TYPE_EXTENSIONS = 5,
ACPI_IBFT_TYPE_RESERVED = 6,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ibft_control {
pub Header: ACPI_IBFT_HEADER,
pub Extensions: UINT16,
pub InitiatorOffset: UINT16,
pub Nic0Offset: UINT16,
pub Target0Offset: UINT16,
pub Nic1Offset: UINT16,
pub Target1Offset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_ibft_control {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ibft_control {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IBFT_CONTROL = Struct_acpi_ibft_control;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ibft_initiator {
pub Header: ACPI_IBFT_HEADER,
pub SnsServer: [UINT8; 16usize],
pub SlpServer: [UINT8; 16usize],
pub PrimaryServer: [UINT8; 16usize],
pub SecondaryServer: [UINT8; 16usize],
pub NameLength: UINT16,
pub NameOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_ibft_initiator {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ibft_initiator {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IBFT_INITIATOR = Struct_acpi_ibft_initiator;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ibft_nic {
pub Header: ACPI_IBFT_HEADER,
pub IpAddress: [UINT8; 16usize],
pub SubnetMaskPrefix: UINT8,
pub Origin: UINT8,
pub Gateway: [UINT8; 16usize],
pub PrimaryDns: [UINT8; 16usize],
pub SecondaryDns: [UINT8; 16usize],
pub Dhcp: [UINT8; 16usize],
pub Vlan: UINT16,
pub MacAddress: [UINT8; 6usize],
pub PciAddress: UINT16,
pub NameLength: UINT16,
pub NameOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_ibft_nic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ibft_nic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IBFT_NIC = Struct_acpi_ibft_nic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ibft_target {
pub Header: ACPI_IBFT_HEADER,
pub TargetIpAddress: [UINT8; 16usize],
pub TargetIpSocket: UINT16,
pub TargetBootLun: [UINT8; 8usize],
pub ChapType: UINT8,
pub NicAssociation: UINT8,
pub TargetNameLength: UINT16,
pub TargetNameOffset: UINT16,
pub ChapNameLength: UINT16,
pub ChapNameOffset: UINT16,
pub ChapSecretLength: UINT16,
pub ChapSecretOffset: UINT16,
pub ReverseChapNameLength: UINT16,
pub ReverseChapNameOffset: UINT16,
pub ReverseChapSecretLength: UINT16,
pub ReverseChapSecretOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_ibft_target {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ibft_target {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IBFT_TARGET = Struct_acpi_ibft_target;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_iort {
pub Header: ACPI_TABLE_HEADER,
pub NodeCount: UINT32,
pub NodeOffset: UINT32,
pub Reserved: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_iort {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_iort {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_IORT = Struct_acpi_table_iort;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_node {
pub Type: UINT8,
pub Length: UINT16,
pub Revision: UINT8,
pub Reserved: UINT32,
pub MappingCount: UINT32,
pub MappingOffset: UINT32,
pub NodeData: [i8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_iort_node {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_node {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_NODE = Struct_acpi_iort_node;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiIortNodeType {
ACPI_IORT_NODE_ITS_GROUP = 0,
ACPI_IORT_NODE_NAMED_COMPONENT = 1,
ACPI_IORT_NODE_PCI_ROOT_COMPLEX = 2,
ACPI_IORT_NODE_SMMU = 3,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_id_mapping {
pub InputBase: UINT32,
pub IdCount: UINT32,
pub OutputBase: UINT32,
pub OutputReference: UINT32,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_iort_id_mapping {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_id_mapping {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_ID_MAPPING = Struct_acpi_iort_id_mapping;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_memory_access {
pub CacheCoherency: UINT32,
pub Hints: UINT8,
pub Reserved: UINT16,
pub MemoryFlags: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_iort_memory_access {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_memory_access {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_MEMORY_ACCESS = Struct_acpi_iort_memory_access;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_its_group {
pub ItsCount: UINT32,
pub Identifiers: [UINT32; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_iort_its_group {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_its_group {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_ITS_GROUP = Struct_acpi_iort_its_group;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_named_component {
pub NodeFlags: UINT32,
pub MemoryProperties: UINT64,
pub MemoryAddressLimit: UINT8,
pub DeviceName: [i8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_iort_named_component {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_named_component {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_NAMED_COMPONENT = Struct_acpi_iort_named_component;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_root_complex {
pub MemoryProperties: UINT64,
pub AtsAttribute: UINT32,
pub PciSegmentNumber: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_iort_root_complex {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_root_complex {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_ROOT_COMPLEX = Struct_acpi_iort_root_complex;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_iort_smmu {
pub BaseAddress: UINT64,
pub Span: UINT64,
pub Model: UINT32,
pub Flags: UINT32,
pub GlobalInterruptOffset: UINT32,
pub ContextInterruptCount: UINT32,
pub ContextInterruptOffset: UINT32,
pub PmuInterruptCount: UINT32,
pub PmuInterruptOffset: UINT32,
pub Interrupts: [UINT64; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_iort_smmu {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_iort_smmu {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IORT_SMMU = Struct_acpi_iort_smmu;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_ivrs {
pub Header: ACPI_TABLE_HEADER,
pub Info: UINT32,
pub Reserved: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_ivrs {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_ivrs {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_IVRS = Struct_acpi_table_ivrs;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_header {
pub Type: UINT8,
pub Flags: UINT8,
pub Length: UINT16,
pub DeviceId: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_HEADER = Struct_acpi_ivrs_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiIvrsType {
ACPI_IVRS_TYPE_HARDWARE = 16,
ACPI_IVRS_TYPE_MEMORY1 = 32,
ACPI_IVRS_TYPE_MEMORY2 = 33,
ACPI_IVRS_TYPE_MEMORY3 = 34,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_hardware {
pub Header: ACPI_IVRS_HEADER,
pub CapabilityOffset: UINT16,
pub BaseAddress: UINT64,
pub PciSegmentGroup: UINT16,
pub Info: UINT16,
pub Reserved: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_hardware {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_hardware {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_HARDWARE = Struct_acpi_ivrs_hardware;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_de_header {
pub Type: UINT8,
pub Id: UINT16,
pub DataSetting: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_de_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_de_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_DE_HEADER = Struct_acpi_ivrs_de_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiIvrsDeviceEntryType {
ACPI_IVRS_TYPE_PAD4 = 0,
ACPI_IVRS_TYPE_ALL = 1,
ACPI_IVRS_TYPE_SELECT = 2,
ACPI_IVRS_TYPE_START = 3,
ACPI_IVRS_TYPE_END = 4,
ACPI_IVRS_TYPE_PAD8 = 64,
ACPI_IVRS_TYPE_NOT_USED = 65,
ACPI_IVRS_TYPE_ALIAS_SELECT = 66,
ACPI_IVRS_TYPE_ALIAS_START = 67,
ACPI_IVRS_TYPE_EXT_SELECT = 70,
ACPI_IVRS_TYPE_EXT_START = 71,
ACPI_IVRS_TYPE_SPECIAL = 72,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_device4 {
pub Header: ACPI_IVRS_DE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_device4 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_device4 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_DEVICE4 = Struct_acpi_ivrs_device4;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_device8a {
pub Header: ACPI_IVRS_DE_HEADER,
pub Reserved1: UINT8,
pub UsedId: UINT16,
pub Reserved2: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_device8a {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_device8a {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_DEVICE8A = Struct_acpi_ivrs_device8a;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_device8b {
pub Header: ACPI_IVRS_DE_HEADER,
pub ExtendedData: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_device8b {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_device8b {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_DEVICE8B = Struct_acpi_ivrs_device8b;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_device8c {
pub Header: ACPI_IVRS_DE_HEADER,
pub Handle: UINT8,
pub UsedId: UINT16,
pub Variety: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_device8c {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_device8c {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_DEVICE8C = Struct_acpi_ivrs_device8c;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_ivrs_memory {
pub Header: ACPI_IVRS_HEADER,
pub AuxData: UINT16,
pub Reserved: UINT64,
pub StartAddress: UINT64,
pub MemoryLength: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_ivrs_memory {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_ivrs_memory {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IVRS_MEMORY = Struct_acpi_ivrs_memory;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_lpit {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_lpit {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_lpit {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_LPIT = Struct_acpi_table_lpit;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_lpit_header {
pub Type: UINT32,
pub Length: UINT32,
pub UniqueId: UINT16,
pub Reserved: UINT16,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_lpit_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_lpit_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_LPIT_HEADER = Struct_acpi_lpit_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiLpitType {
ACPI_LPIT_TYPE_NATIVE_CSTATE = 0,
ACPI_LPIT_TYPE_RESERVED = 1,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_lpit_native {
pub Header: ACPI_LPIT_HEADER,
pub EntryTrigger: ACPI_GENERIC_ADDRESS,
pub Residency: UINT32,
pub Latency: UINT32,
pub ResidencyCounter: ACPI_GENERIC_ADDRESS,
pub CounterFrequency: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_lpit_native {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_lpit_native {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_LPIT_NATIVE = Struct_acpi_lpit_native;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_mcfg {
pub Header: ACPI_TABLE_HEADER,
pub Reserved: [UINT8; 8usize],
}
impl ::core::clone::Clone for Struct_acpi_table_mcfg {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_mcfg {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MCFG = Struct_acpi_table_mcfg;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mcfg_allocation {
pub Address: UINT64,
pub PciSegment: UINT16,
pub StartBusNumber: UINT8,
pub EndBusNumber: UINT8,
pub Reserved: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_mcfg_allocation {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mcfg_allocation {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MCFG_ALLOCATION = Struct_acpi_mcfg_allocation;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_mchi {
pub Header: ACPI_TABLE_HEADER,
pub InterfaceType: UINT8,
pub Protocol: UINT8,
pub ProtocolData: UINT64,
pub InterruptType: UINT8,
pub Gpe: UINT8,
pub PciDeviceFlag: UINT8,
pub GlobalInterrupt: UINT32,
pub ControlRegister: ACPI_GENERIC_ADDRESS,
pub PciSegment: UINT8,
pub PciBus: UINT8,
pub PciDevice: UINT8,
pub PciFunction: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_mchi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_mchi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MCHI = Struct_acpi_table_mchi;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_msdm {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_msdm {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_msdm {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MSDM = Struct_acpi_table_msdm;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_mtmr {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_mtmr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_mtmr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MTMR = Struct_acpi_table_mtmr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mtmr_entry {
pub PhysicalAddress: ACPI_GENERIC_ADDRESS,
pub Frequency: UINT32,
pub Irq: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_mtmr_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mtmr_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MTMR_ENTRY = Struct_acpi_mtmr_entry;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_slic {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_slic {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_slic {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SLIC = Struct_acpi_table_slic;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_spcr {
pub Header: ACPI_TABLE_HEADER,
pub InterfaceType: UINT8,
pub Reserved: [UINT8; 3usize],
pub SerialPort: ACPI_GENERIC_ADDRESS,
pub InterruptType: UINT8,
pub PcInterrupt: UINT8,
pub Interrupt: UINT32,
pub BaudRate: UINT8,
pub Parity: UINT8,
pub StopBits: UINT8,
pub FlowControl: UINT8,
pub TerminalType: UINT8,
pub Reserved1: UINT8,
pub PciDeviceId: UINT16,
pub PciVendorId: UINT16,
pub PciBus: UINT8,
pub PciDevice: UINT8,
pub PciFunction: UINT8,
pub PciFlags: UINT32,
pub PciSegment: UINT8,
pub Reserved2: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_spcr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_spcr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SPCR = Struct_acpi_table_spcr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_spmi {
pub Header: ACPI_TABLE_HEADER,
pub InterfaceType: UINT8,
pub Reserved: UINT8,
pub SpecRevision: UINT16,
pub InterruptType: UINT8,
pub GpeNumber: UINT8,
pub Reserved1: UINT8,
pub PciDeviceFlag: UINT8,
pub Interrupt: UINT32,
pub IpmiRegister: ACPI_GENERIC_ADDRESS,
pub PciSegment: UINT8,
pub PciBus: UINT8,
pub PciDevice: UINT8,
pub PciFunction: UINT8,
pub Reserved2: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_spmi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_spmi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_SPMI = Struct_acpi_table_spmi;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiSpmiInterfaceTypes {
ACPI_SPMI_NOT_USED = 0,
ACPI_SPMI_KEYBOARD = 1,
ACPI_SPMI_SMI = 2,
ACPI_SPMI_BLOCK_TRANSFER = 3,
ACPI_SPMI_SMBUS = 4,
ACPI_SPMI_RESERVED = 5,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_tcpa_hdr {
pub Header: ACPI_TABLE_HEADER,
pub PlatformClass: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_table_tcpa_hdr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_tcpa_hdr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_TCPA_HDR = Struct_acpi_table_tcpa_hdr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_tcpa_client {
pub MinimumLogLength: UINT32,
pub LogAddress: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_tcpa_client {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_tcpa_client {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_TCPA_CLIENT = Struct_acpi_table_tcpa_client;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_tcpa_server {
pub Reserved: UINT16,
pub MinimumLogLength: UINT64,
pub LogAddress: UINT64,
pub SpecRevision: UINT16,
pub DeviceFlags: UINT8,
pub InterruptFlags: UINT8,
pub GpeNumber: UINT8,
pub Reserved2: [UINT8; 3usize],
pub GlobalInterrupt: UINT32,
pub Address: ACPI_GENERIC_ADDRESS,
pub Reserved3: UINT32,
pub ConfigAddress: ACPI_GENERIC_ADDRESS,
pub Group: UINT8,
pub Bus: UINT8,
pub Device: UINT8,
pub Function: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_tcpa_server {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_tcpa_server {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_TCPA_SERVER = Struct_acpi_table_tcpa_server;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_tpm2 {
pub Header: ACPI_TABLE_HEADER,
pub PlatformClass: UINT16,
pub Reserved: UINT16,
pub ControlAddress: UINT64,
pub StartMethod: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_tpm2 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_tpm2 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_TPM2 = Struct_acpi_table_tpm2;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_uefi {
pub Header: ACPI_TABLE_HEADER,
pub Identifier: [UINT8; 16usize],
pub DataOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_table_uefi {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_uefi {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_UEFI = Struct_acpi_table_uefi;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_vrtc {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_vrtc {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_vrtc {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_VRTC = Struct_acpi_table_vrtc;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_vrtc_entry {
pub PhysicalAddress: ACPI_GENERIC_ADDRESS,
pub Irq: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_vrtc_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_vrtc_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_VRTC_ENTRY = Struct_acpi_vrtc_entry;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_waet {
pub Header: ACPI_TABLE_HEADER,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_waet {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_waet {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_WAET = Struct_acpi_table_waet;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_wdat {
pub Header: ACPI_TABLE_HEADER,
pub HeaderLength: UINT32,
pub PciSegment: UINT16,
pub PciBus: UINT8,
pub PciDevice: UINT8,
pub PciFunction: UINT8,
pub Reserved: [UINT8; 3usize],
pub TimerPeriod: UINT32,
pub MaxCount: UINT32,
pub MinCount: UINT32,
pub Flags: UINT8,
pub Reserved2: [UINT8; 3usize],
pub Entries: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_wdat {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_wdat {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_WDAT = Struct_acpi_table_wdat;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_wdat_entry {
pub Action: UINT8,
pub Instruction: UINT8,
pub Reserved: UINT16,
pub RegisterRegion: ACPI_GENERIC_ADDRESS,
pub Value: UINT32,
pub Mask: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_wdat_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_wdat_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_WDAT_ENTRY = Struct_acpi_wdat_entry;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiWdatActions {
ACPI_WDAT_RESET = 1,
ACPI_WDAT_GET_CURRENT_COUNTDOWN = 4,
ACPI_WDAT_GET_COUNTDOWN = 5,
ACPI_WDAT_SET_COUNTDOWN = 6,
ACPI_WDAT_GET_RUNNING_STATE = 8,
ACPI_WDAT_SET_RUNNING_STATE = 9,
ACPI_WDAT_GET_STOPPED_STATE = 10,
ACPI_WDAT_SET_STOPPED_STATE = 11,
ACPI_WDAT_GET_REBOOT = 16,
ACPI_WDAT_SET_REBOOT = 17,
ACPI_WDAT_GET_SHUTDOWN = 18,
ACPI_WDAT_SET_SHUTDOWN = 19,
ACPI_WDAT_GET_STATUS = 32,
ACPI_WDAT_SET_STATUS = 33,
ACPI_WDAT_ACTION_RESERVED = 34,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiWdatInstructions {
ACPI_WDAT_READ_VALUE = 0,
ACPI_WDAT_READ_COUNTDOWN = 1,
ACPI_WDAT_WRITE_VALUE = 2,
ACPI_WDAT_WRITE_COUNTDOWN = 3,
ACPI_WDAT_INSTRUCTION_RESERVED = 4,
ACPI_WDAT_PRESERVE_REGISTER = 128,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_wddt {
pub Header: ACPI_TABLE_HEADER,
pub SpecVersion: UINT16,
pub TableVersion: UINT16,
pub PciVendorId: UINT16,
pub Address: ACPI_GENERIC_ADDRESS,
pub MaxCount: UINT16,
pub MinCount: UINT16,
pub Period: UINT16,
pub Status: UINT16,
pub Capability: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_table_wddt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_wddt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_WDDT = Struct_acpi_table_wddt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_wdrt {
pub Header: ACPI_TABLE_HEADER,
pub ControlRegister: ACPI_GENERIC_ADDRESS,
pub CountRegister: ACPI_GENERIC_ADDRESS,
pub PciDeviceId: UINT16,
pub PciVendorId: UINT16,
pub PciBus: UINT8,
pub PciDevice: UINT8,
pub PciFunction: UINT8,
pub PciSegment: UINT8,
pub MaxCount: UINT16,
pub Units: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_wdrt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_wdrt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_WDRT = Struct_acpi_table_wdrt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_bgrt {
pub Header: ACPI_TABLE_HEADER,
pub Version: UINT16,
pub Status: UINT8,
pub ImageType: UINT8,
pub ImageAddress: UINT64,
pub ImageOffsetX: UINT32,
pub ImageOffsetY: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_bgrt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_bgrt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_BGRT = Struct_acpi_table_bgrt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_drtm {
pub Header: ACPI_TABLE_HEADER,
pub EntryBaseAddress: UINT64,
pub EntryLength: UINT64,
pub EntryAddress32: UINT32,
pub EntryAddress64: UINT64,
pub ExitAddress: UINT64,
pub LogAreaAddress: UINT64,
pub LogAreaLength: UINT32,
pub ArchDependentAddress: UINT64,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_drtm {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_drtm {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_DRTM = Struct_acpi_table_drtm;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_drtm_vtable_list {
pub ValidatedTableCount: UINT32,
pub ValidatedTables: [UINT64; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_drtm_vtable_list {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_drtm_vtable_list {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DRTM_VTABLE_LIST = Struct_acpi_drtm_vtable_list;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_drtm_resource {
pub Size: [UINT8; 7usize],
pub Type: UINT8,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_drtm_resource {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_drtm_resource {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DRTM_RESOURCE = Struct_acpi_drtm_resource;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_drtm_resource_list {
pub ResourceCount: UINT32,
pub Resources: [ACPI_DRTM_RESOURCE; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_drtm_resource_list {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_drtm_resource_list {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DRTM_RESOURCE_LIST = Struct_acpi_drtm_resource_list;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_drtm_dps_id {
pub DpsIdLength: UINT32,
pub DpsId: [UINT8; 16usize],
}
impl ::core::clone::Clone for Struct_acpi_drtm_dps_id {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_drtm_dps_id {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_DRTM_DPS_ID = Struct_acpi_drtm_dps_id;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_fpdt {
pub Header: ACPI_TABLE_HEADER,
}
impl ::core::clone::Clone for Struct_acpi_table_fpdt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_fpdt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_FPDT = Struct_acpi_table_fpdt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_fpdt_header {
pub Type: UINT16,
pub Length: UINT8,
pub Revision: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_fpdt_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_fpdt_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_FPDT_HEADER = Struct_acpi_fpdt_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiFpdtType {
ACPI_FPDT_TYPE_BOOT = 0,
ACPI_FPDT_TYPE_S3PERF = 1,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_fpdt_boot {
pub Header: ACPI_FPDT_HEADER,
pub Reserved: [UINT8; 4usize],
pub ResetEnd: UINT64,
pub LoadStart: UINT64,
pub StartupStart: UINT64,
pub ExitServicesEntry: UINT64,
pub ExitServicesExit: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_fpdt_boot {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_fpdt_boot {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_FPDT_BOOT = Struct_acpi_fpdt_boot;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_fpdt_s3pt_ptr {
pub Header: ACPI_FPDT_HEADER,
pub Reserved: [UINT8; 4usize],
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_fpdt_s3pt_ptr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_fpdt_s3pt_ptr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_FPDT_S3PT_PTR = Struct_acpi_fpdt_s3pt_ptr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_s3pt {
pub Signature: [UINT8; 4usize],
pub Length: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_s3pt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_s3pt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_S3PT = Struct_acpi_table_s3pt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_s3pt_header {
pub Type: UINT16,
pub Length: UINT8,
pub Revision: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_s3pt_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_s3pt_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_S3PT_HEADER = Struct_acpi_s3pt_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiS3ptType {
ACPI_S3PT_TYPE_RESUME = 0,
ACPI_S3PT_TYPE_SUSPEND = 1,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_s3pt_resume {
pub Header: ACPI_S3PT_HEADER,
pub ResumeCount: UINT32,
pub FullResume: UINT64,
pub AverageResume: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_s3pt_resume {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_s3pt_resume {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_S3PT_RESUME = Struct_acpi_s3pt_resume;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_s3pt_suspend {
pub Header: ACPI_S3PT_HEADER,
pub SuspendStart: UINT64,
pub SuspendEnd: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_s3pt_suspend {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_s3pt_suspend {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_S3PT_SUSPEND = Struct_acpi_s3pt_suspend;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_gtdt {
pub Header: ACPI_TABLE_HEADER,
pub CounterBlockAddresss: UINT64,
pub Reserved: UINT32,
pub SecureEl1Interrupt: UINT32,
pub SecureEl1Flags: UINT32,
pub NonSecureEl1Interrupt: UINT32,
pub NonSecureEl1Flags: UINT32,
pub VirtualTimerInterrupt: UINT32,
pub VirtualTimerFlags: UINT32,
pub NonSecureEl2Interrupt: UINT32,
pub NonSecureEl2Flags: UINT32,
pub CounterReadBlockAddress: UINT64,
pub PlatformTimerCount: UINT32,
pub PlatformTimerOffset: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_gtdt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_gtdt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_GTDT = Struct_acpi_table_gtdt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_gtdt_header {
pub Type: UINT8,
pub Length: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_gtdt_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_gtdt_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GTDT_HEADER = Struct_acpi_gtdt_header;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiGtdtType {
ACPI_GTDT_TYPE_TIMER_BLOCK = 0,
ACPI_GTDT_TYPE_WATCHDOG = 1,
ACPI_GTDT_TYPE_RESERVED = 2,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_gtdt_timer_block {
pub Header: ACPI_GTDT_HEADER,
pub Reserved: UINT8,
pub BlockAddress: UINT64,
pub TimerCount: UINT32,
pub TimerOffset: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_gtdt_timer_block {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_gtdt_timer_block {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GTDT_TIMER_BLOCK = Struct_acpi_gtdt_timer_block;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_gtdt_timer_entry {
pub FrameNumber: UINT8,
pub Reserved: [UINT8; 3usize],
pub BaseAddress: UINT64,
pub El0BaseAddress: UINT64,
pub TimerInterrupt: UINT32,
pub TimerFlags: UINT32,
pub VirtualTimerInterrupt: UINT32,
pub VirtualTimerFlags: UINT32,
pub CommonFlags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_gtdt_timer_entry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_gtdt_timer_entry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GTDT_TIMER_ENTRY = Struct_acpi_gtdt_timer_entry;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_gtdt_watchdog {
pub Header: ACPI_GTDT_HEADER,
pub Reserved: UINT8,
pub RefreshFrameAddress: UINT64,
pub ControlFrameAddress: UINT64,
pub TimerInterrupt: UINT32,
pub TimerFlags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_gtdt_watchdog {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_gtdt_watchdog {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GTDT_WATCHDOG = Struct_acpi_gtdt_watchdog;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_mpst {
pub Header: ACPI_TABLE_HEADER,
pub ChannelId: UINT8,
pub Reserved1: [UINT8; 3usize],
pub PowerNodeCount: UINT16,
pub Reserved2: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_table_mpst {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_mpst {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_MPST = Struct_acpi_table_mpst;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_channel {
pub ChannelId: UINT8,
pub Reserved1: [UINT8; 3usize],
pub PowerNodeCount: UINT16,
pub Reserved2: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_mpst_channel {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_channel {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_CHANNEL = Struct_acpi_mpst_channel;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_power_node {
pub Flags: UINT8,
pub Reserved1: UINT8,
pub NodeId: UINT16,
pub Length: UINT32,
pub RangeAddress: UINT64,
pub RangeLength: UINT64,
pub NumPowerStates: UINT32,
pub NumPhysicalComponents: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_mpst_power_node {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_power_node {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_POWER_NODE = Struct_acpi_mpst_power_node;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_power_state {
pub PowerState: UINT8,
pub InfoIndex: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_mpst_power_state {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_power_state {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_POWER_STATE = Struct_acpi_mpst_power_state;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_component {
pub ComponentId: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_mpst_component {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_component {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_COMPONENT = Struct_acpi_mpst_component;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_data_hdr {
pub CharacteristicsCount: UINT16,
pub Reserved: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_mpst_data_hdr {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_data_hdr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_DATA_HDR = Struct_acpi_mpst_data_hdr;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_power_data {
pub StructureId: UINT8,
pub Flags: UINT8,
pub Reserved1: UINT16,
pub AveragePower: UINT32,
pub PowerSaving: UINT32,
pub ExitLatency: UINT64,
pub Reserved2: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_mpst_power_data {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_power_data {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_POWER_DATA = Struct_acpi_mpst_power_data;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_mpst_shared {
pub Signature: UINT32,
pub PccCommand: UINT16,
pub PccStatus: UINT16,
pub CommandRegister: UINT32,
pub StatusRegister: UINT32,
pub PowerStateId: UINT32,
pub PowerNodeId: UINT32,
pub EnergyConsumed: UINT64,
pub AveragePower: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_mpst_shared {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_mpst_shared {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MPST_SHARED = Struct_acpi_mpst_shared;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_pcct {
pub Header: ACPI_TABLE_HEADER,
pub Flags: UINT32,
pub Reserved: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_table_pcct {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_pcct {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_PCCT = Struct_acpi_table_pcct;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiPcctType {
ACPI_PCCT_TYPE_GENERIC_SUBSPACE = 0,
ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE = 1,
ACPI_PCCT_TYPE_RESERVED = 2,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pcct_subspace {
pub Header: ACPI_SUBTABLE_HEADER,
pub Reserved: [UINT8; 6usize],
pub BaseAddress: UINT64,
pub Length: UINT64,
pub DoorbellRegister: ACPI_GENERIC_ADDRESS,
pub PreserveMask: UINT64,
pub WriteMask: UINT64,
pub Latency: UINT32,
pub MaxAccessRate: UINT32,
pub MinTurnaroundTime: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pcct_subspace {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pcct_subspace {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PCCT_SUBSPACE = Struct_acpi_pcct_subspace;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pcct_hw_reduced {
pub Header: ACPI_SUBTABLE_HEADER,
pub DoorbellInterrupt: UINT32,
pub Flags: UINT8,
pub Reserved: UINT8,
pub BaseAddress: UINT64,
pub Length: UINT64,
pub DoorbellRegister: ACPI_GENERIC_ADDRESS,
pub PreserveMask: UINT64,
pub WriteMask: UINT64,
pub Latency: UINT32,
pub MaxAccessRate: UINT32,
pub MinTurnaroundTime: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pcct_hw_reduced {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pcct_hw_reduced {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PCCT_HW_REDUCED = Struct_acpi_pcct_hw_reduced;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pcct_shared_memory {
pub Signature: UINT32,
pub Command: UINT16,
pub Status: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pcct_shared_memory {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pcct_shared_memory {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PCCT_SHARED_MEMORY = Struct_acpi_pcct_shared_memory;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_pmtt {
pub Header: ACPI_TABLE_HEADER,
pub Reserved: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_table_pmtt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_pmtt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_PMTT = Struct_acpi_table_pmtt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pmtt_header {
pub Type: UINT8,
pub Reserved1: UINT8,
pub Length: UINT16,
pub Flags: UINT16,
pub Reserved2: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pmtt_header {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pmtt_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PMTT_HEADER = Struct_acpi_pmtt_header;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pmtt_socket {
pub Header: ACPI_PMTT_HEADER,
pub SocketId: UINT16,
pub Reserved: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pmtt_socket {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pmtt_socket {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PMTT_SOCKET = Struct_acpi_pmtt_socket;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pmtt_controller {
pub Header: ACPI_PMTT_HEADER,
pub ReadLatency: UINT32,
pub WriteLatency: UINT32,
pub ReadBandwidth: UINT32,
pub WriteBandwidth: UINT32,
pub AccessWidth: UINT16,
pub Alignment: UINT16,
pub Reserved: UINT16,
pub DomainCount: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pmtt_controller {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pmtt_controller {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PMTT_CONTROLLER = Struct_acpi_pmtt_controller;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pmtt_domain {
pub ProximityDomain: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_pmtt_domain {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pmtt_domain {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PMTT_DOMAIN = Struct_acpi_pmtt_domain;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pmtt_physical_component {
pub Header: ACPI_PMTT_HEADER,
pub ComponentId: UINT16,
pub Reserved: UINT16,
pub MemorySize: UINT32,
pub BiosHandle: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_pmtt_physical_component {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pmtt_physical_component {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PMTT_PHYSICAL_COMPONENT = Struct_acpi_pmtt_physical_component;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_rasf {
pub Header: ACPI_TABLE_HEADER,
pub ChannelId: [UINT8; 12usize],
}
impl ::core::clone::Clone for Struct_acpi_table_rasf {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_rasf {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_RASF = Struct_acpi_table_rasf;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_rasf_shared_memory {
pub Signature: UINT32,
pub Command: UINT16,
pub Status: UINT16,
pub Version: UINT16,
pub Capabilities: [UINT8; 16usize],
pub SetCapabilities: [UINT8; 16usize],
pub NumParameterBlocks: UINT16,
pub SetCapabilitiesStatus: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_rasf_shared_memory {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_rasf_shared_memory {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RASF_SHARED_MEMORY = Struct_acpi_rasf_shared_memory;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_rasf_parameter_block {
pub Type: UINT16,
pub Version: UINT16,
pub Length: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_rasf_parameter_block {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_rasf_parameter_block {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RASF_PARAMETER_BLOCK = Struct_acpi_rasf_parameter_block;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_rasf_patrol_scrub_parameter {
pub Header: ACPI_RASF_PARAMETER_BLOCK,
pub PatrolScrubCommand: UINT16,
pub RequestedAddressRange: [UINT64; 2usize],
pub ActualAddressRange: [UINT64; 2usize],
pub Flags: UINT16,
pub RequestedSpeed: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_rasf_patrol_scrub_parameter {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_rasf_patrol_scrub_parameter {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RASF_PATROL_SCRUB_PARAMETER =
Struct_acpi_rasf_patrol_scrub_parameter;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiRasfCommands { ACPI_RASF_EXECUTE_RASF_COMMAND = 1, _UNUSED_VARIANT = 2, }
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiRasfCapabiliities {
ACPI_HW_PATROL_SCRUB_SUPPORTED = 0,
ACPI_SW_PATROL_SCRUB_EXPOSED = 1,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiRasfPatrolScrubCommands {
ACPI_RASF_GET_PATROL_PARAMETERS = 1,
ACPI_RASF_START_PATROL_SCRUBBER = 2,
ACPI_RASF_STOP_PATROL_SCRUBBER = 3,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_AcpiRasfStatus {
ACPI_RASF_SUCCESS = 0,
ACPI_RASF_NOT_VALID = 1,
ACPI_RASF_NOT_SUPPORTED = 2,
ACPI_RASF_BUSY = 3,
ACPI_RASF_FAILED = 4,
ACPI_RASF_ABORTED = 5,
ACPI_RASF_INVALID_DATA = 6,
}
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_stao {
pub Header: ACPI_TABLE_HEADER,
pub IgnoreUart: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_stao {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_stao {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_STAO = Struct_acpi_table_stao;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_wpbt {
pub Header: ACPI_TABLE_HEADER,
pub HandoffSize: UINT32,
pub HandoffAddress: UINT64,
pub Layout: UINT8,
pub Type: UINT8,
pub ArgumentsLength: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_table_wpbt {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_wpbt {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_WPBT = Struct_acpi_table_wpbt;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_table_xenv {
pub Header: ACPI_TABLE_HEADER,
pub GrantTableAddress: UINT64,
pub GrantTableSize: UINT64,
pub EventInterrupt: UINT32,
pub EventFlags: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_table_xenv {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_table_xenv {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_TABLE_XENV = Struct_acpi_table_xenv;
pub type ACPI_RS_LENGTH = UINT16;
pub type ACPI_RSDESC_SIZE = UINT32;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_uuid {
pub Data: [UINT8; 16usize],
}
impl ::core::clone::Clone for Struct_acpi_uuid {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_uuid {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_UUID = Struct_acpi_uuid;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_vendor_uuid {
pub Subtype: UINT8,
pub Data: [UINT8; 16usize],
}
impl ::core::clone::Clone for Struct_acpi_vendor_uuid {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_vendor_uuid {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_VENDOR_UUID = Struct_acpi_vendor_uuid;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_irq {
pub DescriptorLength: UINT8,
pub Triggering: UINT8,
pub Polarity: UINT8,
pub Sharable: UINT8,
pub WakeCapable: UINT8,
pub InterruptCount: UINT8,
pub Interrupts: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_resource_irq {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_irq {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_IRQ = Struct_acpi_resource_irq;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_dma {
pub Type: UINT8,
pub BusMaster: UINT8,
pub Transfer: UINT8,
pub ChannelCount: UINT8,
pub Channels: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_resource_dma {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_dma {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_DMA = Struct_acpi_resource_dma;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_start_dependent {
pub DescriptorLength: UINT8,
pub CompatibilityPriority: UINT8,
pub PerformanceRobustness: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_start_dependent {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_start_dependent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_START_DEPENDENT = Struct_acpi_resource_start_dependent;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_io {
pub IoDecode: UINT8,
pub Alignment: UINT8,
pub AddressLength: UINT8,
pub Minimum: UINT16,
pub Maximum: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_resource_io {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_io {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_IO = Struct_acpi_resource_io;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_fixed_io {
pub Address: UINT16,
pub AddressLength: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_fixed_io {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_fixed_io {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_FIXED_IO = Struct_acpi_resource_fixed_io;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_fixed_dma {
pub RequestLines: UINT16,
pub Channels: UINT16,
pub Width: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_fixed_dma {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_fixed_dma {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_FIXED_DMA = Struct_acpi_resource_fixed_dma;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_vendor {
pub ByteLength: UINT16,
pub ByteData: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_resource_vendor {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_vendor {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_VENDOR = Struct_acpi_resource_vendor;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_vendor_typed {
pub ByteLength: UINT16,
pub UuidSubtype: UINT8,
pub Uuid: [UINT8; 16usize],
pub ByteData: [UINT8; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_resource_vendor_typed {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_vendor_typed {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_VENDOR_TYPED = Struct_acpi_resource_vendor_typed;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_end_tag {
pub Checksum: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_end_tag {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_end_tag {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_END_TAG = Struct_acpi_resource_end_tag;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_memory24 {
pub WriteProtect: UINT8,
pub Minimum: UINT16,
pub Maximum: UINT16,
pub Alignment: UINT16,
pub AddressLength: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_resource_memory24 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_memory24 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_MEMORY24 = Struct_acpi_resource_memory24;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_memory32 {
pub WriteProtect: UINT8,
pub Minimum: UINT32,
pub Maximum: UINT32,
pub Alignment: UINT32,
pub AddressLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_resource_memory32 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_memory32 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_MEMORY32 = Struct_acpi_resource_memory32;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_fixed_memory32 {
pub WriteProtect: UINT8,
pub Address: UINT32,
pub AddressLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_resource_fixed_memory32 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_fixed_memory32 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_FIXED_MEMORY32 = Struct_acpi_resource_fixed_memory32;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_memory_attribute {
pub WriteProtect: UINT8,
pub Caching: UINT8,
pub RangeType: UINT8,
pub Translation: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_memory_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_memory_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_MEMORY_ATTRIBUTE = Struct_acpi_memory_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_io_attribute {
pub RangeType: UINT8,
pub Translation: UINT8,
pub TranslationType: UINT8,
pub Reserved1: UINT8,
}
impl ::core::clone::Clone for Struct_acpi_io_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_io_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_IO_ATTRIBUTE = Struct_acpi_io_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Union_acpi_resource_attribute {
pub _bindgen_data_: [u8; 4usize],
}
impl Union_acpi_resource_attribute {
pub unsafe fn Mem(&mut self) -> *mut ACPI_MEMORY_ATTRIBUTE {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Io(&mut self) -> *mut ACPI_IO_ATTRIBUTE {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn TypeSpecific(&mut self) -> *mut UINT8 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::clone::Clone for Union_acpi_resource_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Union_acpi_resource_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_ATTRIBUTE = Union_acpi_resource_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_source {
pub Index: UINT8,
pub StringLength: UINT16,
pub StringPtr: *mut i8,
}
impl ::core::clone::Clone for Struct_acpi_resource_source {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_source {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_SOURCE = Struct_acpi_resource_source;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_address16_attribute {
pub Granularity: UINT16,
pub Minimum: UINT16,
pub Maximum: UINT16,
pub TranslationOffset: UINT16,
pub AddressLength: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_address16_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_address16_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ADDRESS16_ATTRIBUTE = Struct_acpi_address16_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_address32_attribute {
pub Granularity: UINT32,
pub Minimum: UINT32,
pub Maximum: UINT32,
pub TranslationOffset: UINT32,
pub AddressLength: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_address32_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_address32_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ADDRESS32_ATTRIBUTE = Struct_acpi_address32_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_address64_attribute {
pub Granularity: UINT64,
pub Minimum: UINT64,
pub Maximum: UINT64,
pub TranslationOffset: UINT64,
pub AddressLength: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_address64_attribute {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_address64_attribute {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_ADDRESS64_ATTRIBUTE = Struct_acpi_address64_attribute;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_address {
pub ResourceType: UINT8,
pub ProducerConsumer: UINT8,
pub Decode: UINT8,
pub MinAddressFixed: UINT8,
pub MaxAddressFixed: UINT8,
pub Info: ACPI_RESOURCE_ATTRIBUTE,
}
impl ::core::clone::Clone for Struct_acpi_resource_address {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_address {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_ADDRESS = Struct_acpi_resource_address;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_address16 {
pub ResourceType: UINT8,
pub ProducerConsumer: UINT8,
pub Decode: UINT8,
pub MinAddressFixed: UINT8,
pub MaxAddressFixed: UINT8,
pub Info: ACPI_RESOURCE_ATTRIBUTE,
pub Address: ACPI_ADDRESS16_ATTRIBUTE,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
}
impl ::core::clone::Clone for Struct_acpi_resource_address16 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_address16 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_ADDRESS16 = Struct_acpi_resource_address16;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_address32 {
pub ResourceType: UINT8,
pub ProducerConsumer: UINT8,
pub Decode: UINT8,
pub MinAddressFixed: UINT8,
pub MaxAddressFixed: UINT8,
pub Info: ACPI_RESOURCE_ATTRIBUTE,
pub Address: ACPI_ADDRESS32_ATTRIBUTE,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
}
impl ::core::clone::Clone for Struct_acpi_resource_address32 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_address32 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_ADDRESS32 = Struct_acpi_resource_address32;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_address64 {
pub ResourceType: UINT8,
pub ProducerConsumer: UINT8,
pub Decode: UINT8,
pub MinAddressFixed: UINT8,
pub MaxAddressFixed: UINT8,
pub Info: ACPI_RESOURCE_ATTRIBUTE,
pub Address: ACPI_ADDRESS64_ATTRIBUTE,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
}
impl ::core::clone::Clone for Struct_acpi_resource_address64 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_address64 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_ADDRESS64 = Struct_acpi_resource_address64;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_extended_address64 {
pub ResourceType: UINT8,
pub ProducerConsumer: UINT8,
pub Decode: UINT8,
pub MinAddressFixed: UINT8,
pub MaxAddressFixed: UINT8,
pub Info: ACPI_RESOURCE_ATTRIBUTE,
pub RevisionID: UINT8,
pub Address: ACPI_ADDRESS64_ATTRIBUTE,
pub TypeSpecific: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_resource_extended_address64 {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_extended_address64 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_EXTENDED_ADDRESS64 =
Struct_acpi_resource_extended_address64;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_extended_irq {
pub ProducerConsumer: UINT8,
pub Triggering: UINT8,
pub Polarity: UINT8,
pub Sharable: UINT8,
pub WakeCapable: UINT8,
pub InterruptCount: UINT8,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub Interrupts: [UINT32; 1usize],
}
impl ::core::clone::Clone for Struct_acpi_resource_extended_irq {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_extended_irq {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_EXTENDED_IRQ = Struct_acpi_resource_extended_irq;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_generic_register {
pub SpaceId: UINT8,
pub BitWidth: UINT8,
pub BitOffset: UINT8,
pub AccessSize: UINT8,
pub Address: UINT64,
}
impl ::core::clone::Clone for Struct_acpi_resource_generic_register {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_generic_register {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_GENERIC_REGISTER =
Struct_acpi_resource_generic_register;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_gpio {
pub RevisionId: UINT8,
pub ConnectionType: UINT8,
pub ProducerConsumer: UINT8,
pub PinConfig: UINT8,
pub Sharable: UINT8,
pub WakeCapable: UINT8,
pub IoRestriction: UINT8,
pub Triggering: UINT8,
pub Polarity: UINT8,
pub DriveStrength: UINT16,
pub DebounceTimeout: UINT16,
pub PinTableLength: UINT16,
pub VendorLength: UINT16,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub PinTable: *mut UINT16,
pub VendorData: *mut UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_gpio {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_gpio {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_GPIO = Struct_acpi_resource_gpio;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_common_serialbus {
pub RevisionId: UINT8,
pub Type: UINT8,
pub ProducerConsumer: UINT8,
pub SlaveMode: UINT8,
pub TypeRevisionId: UINT8,
pub TypeDataLength: UINT16,
pub VendorLength: UINT16,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub VendorData: *mut UINT8,
}
impl ::core::clone::Clone for Struct_acpi_resource_common_serialbus {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_common_serialbus {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_COMMON_SERIALBUS =
Struct_acpi_resource_common_serialbus;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_i2c_serialbus {
pub RevisionId: UINT8,
pub Type: UINT8,
pub ProducerConsumer: UINT8,
pub SlaveMode: UINT8,
pub TypeRevisionId: UINT8,
pub TypeDataLength: UINT16,
pub VendorLength: UINT16,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub VendorData: *mut UINT8,
pub AccessMode: UINT8,
pub SlaveAddress: UINT16,
pub ConnectionSpeed: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_resource_i2c_serialbus {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_i2c_serialbus {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_I2C_SERIALBUS = Struct_acpi_resource_i2c_serialbus;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_spi_serialbus {
pub RevisionId: UINT8,
pub Type: UINT8,
pub ProducerConsumer: UINT8,
pub SlaveMode: UINT8,
pub TypeRevisionId: UINT8,
pub TypeDataLength: UINT16,
pub VendorLength: UINT16,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub VendorData: *mut UINT8,
pub WireMode: UINT8,
pub DevicePolarity: UINT8,
pub DataBitLength: UINT8,
pub ClockPhase: UINT8,
pub ClockPolarity: UINT8,
pub DeviceSelection: UINT16,
pub ConnectionSpeed: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_resource_spi_serialbus {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_spi_serialbus {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_SPI_SERIALBUS = Struct_acpi_resource_spi_serialbus;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource_uart_serialbus {
pub RevisionId: UINT8,
pub Type: UINT8,
pub ProducerConsumer: UINT8,
pub SlaveMode: UINT8,
pub TypeRevisionId: UINT8,
pub TypeDataLength: UINT16,
pub VendorLength: UINT16,
pub ResourceSource: ACPI_RESOURCE_SOURCE,
pub VendorData: *mut UINT8,
pub Endian: UINT8,
pub DataBits: UINT8,
pub StopBits: UINT8,
pub FlowControl: UINT8,
pub Parity: UINT8,
pub LinesEnabled: UINT8,
pub RxFifoSize: UINT16,
pub TxFifoSize: UINT16,
pub DefaultBaudRate: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_resource_uart_serialbus {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource_uart_serialbus {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_UART_SERIALBUS = Struct_acpi_resource_uart_serialbus;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Union_acpi_resource_data {
pub _bindgen_data_: [u8; 60usize],
}
impl Union_acpi_resource_data {
pub unsafe fn Irq(&mut self) -> *mut ACPI_RESOURCE_IRQ {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Dma(&mut self) -> *mut ACPI_RESOURCE_DMA {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn StartDpf(&mut self) -> *mut ACPI_RESOURCE_START_DEPENDENT {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Io(&mut self) -> *mut ACPI_RESOURCE_IO {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn FixedIo(&mut self) -> *mut ACPI_RESOURCE_FIXED_IO {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn FixedDma(&mut self) -> *mut ACPI_RESOURCE_FIXED_DMA {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Vendor(&mut self) -> *mut ACPI_RESOURCE_VENDOR {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn VendorTyped(&mut self) -> *mut ACPI_RESOURCE_VENDOR_TYPED {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn EndTag(&mut self) -> *mut ACPI_RESOURCE_END_TAG {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Memory24(&mut self) -> *mut ACPI_RESOURCE_MEMORY24 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Memory32(&mut self) -> *mut ACPI_RESOURCE_MEMORY32 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn FixedMemory32(&mut self)
-> *mut ACPI_RESOURCE_FIXED_MEMORY32 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Address16(&mut self) -> *mut ACPI_RESOURCE_ADDRESS16 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Address32(&mut self) -> *mut ACPI_RESOURCE_ADDRESS32 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Address64(&mut self) -> *mut ACPI_RESOURCE_ADDRESS64 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn ExtAddress64(&mut self)
-> *mut ACPI_RESOURCE_EXTENDED_ADDRESS64 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn ExtendedIrq(&mut self) -> *mut ACPI_RESOURCE_EXTENDED_IRQ {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn GenericReg(&mut self)
-> *mut ACPI_RESOURCE_GENERIC_REGISTER {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Gpio(&mut self) -> *mut ACPI_RESOURCE_GPIO {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn I2cSerialBus(&mut self)
-> *mut ACPI_RESOURCE_I2C_SERIALBUS {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn SpiSerialBus(&mut self)
-> *mut ACPI_RESOURCE_SPI_SERIALBUS {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn UartSerialBus(&mut self)
-> *mut ACPI_RESOURCE_UART_SERIALBUS {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn CommonSerialBus(&mut self)
-> *mut ACPI_RESOURCE_COMMON_SERIALBUS {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn Address(&mut self) -> *mut ACPI_RESOURCE_ADDRESS {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::clone::Clone for Union_acpi_resource_data {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Union_acpi_resource_data {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE_DATA = Union_acpi_resource_data;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_resource {
pub Type: UINT32,
pub Length: UINT32,
pub Data: ACPI_RESOURCE_DATA,
}
impl ::core::clone::Clone for Struct_acpi_resource {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_resource {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_RESOURCE = Struct_acpi_resource;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pci_routing_table {
pub Length: UINT32,
pub Pin: UINT32,
pub Address: UINT64,
pub SourceIndex: UINT32,
pub Source: [i8; 4usize],
}
impl ::core::clone::Clone for Struct_acpi_pci_routing_table {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pci_routing_table {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PCI_ROUTING_TABLE = Struct_acpi_pci_routing_table;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed9 {
OSL_GLOBAL_LOCK_HANDLER = 0,
OSL_NOTIFY_HANDLER = 1,
OSL_GPE_HANDLER = 2,
OSL_DEBUGGER_MAIN_THREAD = 3,
OSL_DEBUGGER_EXEC_THREAD = 4,
OSL_EC_POLL_HANDLER = 5,
OSL_EC_BURST_HANDLER = 6,
}
pub type ACPI_EXECUTE_TYPE = Enum_Unnamed9;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_signal_fatal_info {
pub Type: UINT32,
pub Code: UINT32,
pub Argument: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_signal_fatal_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_signal_fatal_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_SIGNAL_FATAL_INFO = Struct_acpi_signal_fatal_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_fde_info {
pub Floppy0: UINT32,
pub Floppy1: UINT32,
pub Floppy2: UINT32,
pub Floppy3: UINT32,
pub Tape: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_fde_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_fde_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_FDE_INFO = Struct_acpi_fde_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_grt_info {
pub Year: UINT16,
pub Month: UINT8,
pub Day: UINT8,
pub Hour: UINT8,
pub Minute: UINT8,
pub Second: UINT8,
pub Valid: UINT8,
pub Milliseconds: UINT16,
pub Timezone: UINT16,
pub Daylight: UINT8,
pub Reserved: [UINT8; 3usize],
}
impl ::core::clone::Clone for Struct_acpi_grt_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_grt_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GRT_INFO = Struct_acpi_grt_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_gtm_info {
pub PioSpeed0: UINT32,
pub DmaSpeed0: UINT32,
pub PioSpeed1: UINT32,
pub DmaSpeed1: UINT32,
pub Flags: UINT32,
}
impl ::core::clone::Clone for Struct_acpi_gtm_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_gtm_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_GTM_INFO = Struct_acpi_gtm_info;
#[repr(C, packed)]
#[derive(Copy)]
pub struct Struct_acpi_pld_info {
pub Revision: UINT8,
pub IgnoreColor: UINT8,
pub Red: UINT8,
pub Green: UINT8,
pub Blue: UINT8,
pub Width: UINT16,
pub Height: UINT16,
pub UserVisible: UINT8,
pub Dock: UINT8,
pub Lid: UINT8,
pub Panel: UINT8,
pub VerticalPosition: UINT8,
pub HorizontalPosition: UINT8,
pub Shape: UINT8,
pub GroupOrientation: UINT8,
pub GroupToken: UINT8,
pub GroupPosition: UINT8,
pub Bay: UINT8,
pub Ejectable: UINT8,
pub OspmEjectRequired: UINT8,
pub CabinetNumber: UINT8,
pub CardCageNumber: UINT8,
pub Reference: UINT8,
pub Rotation: UINT8,
pub Order: UINT8,
pub Reserved: UINT8,
pub VerticalOffset: UINT16,
pub HorizontalOffset: UINT16,
}
impl ::core::clone::Clone for Struct_acpi_pld_info {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Struct_acpi_pld_info {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ACPI_PLD_INFO = Struct_acpi_pld_info;
pub type ACPI_WALK_RESOURCE_CALLBACK =
::core::option::Option<unsafe extern "C" fn(Resource: *mut ACPI_RESOURCE,
Context:
*mut c_void)
-> ACPI_STATUS>;
extern "C" {
pub static mut AcpiGbl_EnableInterpreterSlack: UINT8;
pub static mut AcpiGbl_AutoSerializeMethods: UINT8;
pub static mut AcpiGbl_CreateOsiMethod: UINT8;
pub static mut AcpiGbl_UseDefaultRegisterWidths: UINT8;
pub static mut AcpiGbl_VerifyTableChecksum: UINT8;
pub static mut AcpiGbl_EnableAmlDebugObject: UINT8;
pub static mut AcpiGbl_CopyDsdtLocally: UINT8;
pub static mut AcpiGbl_DoNotUseXsdt: UINT8;
pub static mut AcpiGbl_GroupModuleLevelCode: UINT8;
pub static mut AcpiGbl_Use32BitFadtAddresses: UINT8;
pub static mut AcpiGbl_Use32BitFacsAddresses: UINT8;
pub static mut AcpiGbl_TruncateIoAddresses: UINT8;
pub static mut AcpiGbl_DisableAutoRepair: UINT8;
pub static mut AcpiGbl_DisableSsdtTableInstall: UINT8;
pub static mut AcpiGbl_RuntimeNamespaceOverride: UINT8;
pub static mut AcpiGbl_OsiData: UINT8;
pub static mut AcpiGbl_ReducedHardware: BOOLEAN;
pub static mut AcpiGbl_TraceFlags: UINT32;
pub static mut AcpiGbl_TraceMethodName: *const i8;
pub static mut AcpiGbl_TraceDbgLevel: UINT32;
pub static mut AcpiGbl_TraceDbgLayer: UINT32;
pub static mut AcpiDbgLevel: UINT32;
pub static mut AcpiDbgLayer: UINT32;
pub static mut AcpiGbl_DisplayDebugTimer: UINT8;
pub static mut AcpiGbl_FADT: ACPI_TABLE_FADT;
pub static mut AcpiCurrentGpeCount: UINT32;
pub static mut AcpiGbl_SystemAwakeAndRunning: BOOLEAN;
}
extern "C" {
pub fn AcpiInitializeTables(InitialStorage: *mut ACPI_TABLE_DESC,
InitialTableCount: UINT32,
AllowResize: BOOLEAN) -> ACPI_STATUS;
pub fn AcpiInitializeSubsystem() -> ACPI_STATUS;
pub fn AcpiEnableSubsystem(Flags: UINT32) -> ACPI_STATUS;
pub fn AcpiInitializeObjects(Flags: UINT32) -> ACPI_STATUS;
pub fn AcpiTerminate() -> ACPI_STATUS;
pub fn AcpiEnable() -> ACPI_STATUS;
pub fn AcpiDisable() -> ACPI_STATUS;
pub fn AcpiSubsystemStatus() -> ACPI_STATUS;
pub fn AcpiGetSystemInfo(RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiGetStatistics(Stats: *mut ACPI_STATISTICS) -> ACPI_STATUS;
pub fn AcpiFormatException(Exception: ACPI_STATUS)
-> *const i8;
pub fn AcpiPurgeCachedObjects() -> ACPI_STATUS;
pub fn AcpiInstallInterface(InterfaceName: ACPI_STRING) -> ACPI_STATUS;
pub fn AcpiRemoveInterface(InterfaceName: ACPI_STRING) -> ACPI_STATUS;
pub fn AcpiUpdateInterfaces(Action: UINT8) -> ACPI_STATUS;
pub fn AcpiCheckAddressRange(SpaceId: ACPI_ADR_SPACE_TYPE,
Address: ACPI_PHYSICAL_ADDRESS,
Length: ACPI_SIZE, Warn: BOOLEAN) -> UINT32;
pub fn AcpiDecodePldBuffer(InBuffer: *mut UINT8, Length: ACPI_SIZE,
ReturnBuffer: *mut *mut ACPI_PLD_INFO)
-> ACPI_STATUS;
pub fn AcpiInstallTable(Address: ACPI_PHYSICAL_ADDRESS, Physical: BOOLEAN)
-> ACPI_STATUS;
pub fn AcpiLoadTable(Table: *mut ACPI_TABLE_HEADER) -> ACPI_STATUS;
pub fn AcpiUnloadParentTable(Object: ACPI_HANDLE) -> ACPI_STATUS;
pub fn AcpiLoadTables() -> ACPI_STATUS;
pub fn AcpiReallocateRootTable() -> ACPI_STATUS;
pub fn AcpiFindRootPointer(RsdpAddress: *mut ACPI_PHYSICAL_ADDRESS)
-> ACPI_STATUS;
pub fn AcpiGetTableHeader(Signature: ACPI_STRING, Instance: UINT32,
OutTableHeader: *mut ACPI_TABLE_HEADER)
-> ACPI_STATUS;
pub fn AcpiGetTable(Signature: ACPI_STRING, Instance: UINT32,
OutTable: *mut *mut ACPI_TABLE_HEADER) -> ACPI_STATUS;
pub fn AcpiGetTableByIndex(TableIndex: UINT32,
OutTable: *mut *mut ACPI_TABLE_HEADER)
-> ACPI_STATUS;
pub fn AcpiInstallTableHandler(Handler: ACPI_TABLE_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveTableHandler(Handler: ACPI_TABLE_HANDLER) -> ACPI_STATUS;
pub fn AcpiWalkNamespace(Type: ACPI_OBJECT_TYPE, StartObject: ACPI_HANDLE,
MaxDepth: UINT32,
DescendingCallback: ACPI_WALK_CALLBACK,
AscendingCallback: ACPI_WALK_CALLBACK,
Context: *mut c_void,
ReturnValue: *mut *mut c_void)
-> ACPI_STATUS;
pub fn AcpiGetDevices(HID: *mut i8,
UserFunction: ACPI_WALK_CALLBACK,
Context: *mut c_void,
ReturnValue: *mut *mut c_void)
-> ACPI_STATUS;
pub fn AcpiGetName(Object: ACPI_HANDLE, NameType: UINT32,
RetPathPtr: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiGetHandle(Parent: ACPI_HANDLE, Pathname: ACPI_STRING,
RetHandle: *mut ACPI_HANDLE) -> ACPI_STATUS;
pub fn AcpiAttachData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER,
Data: *mut c_void) -> ACPI_STATUS;
pub fn AcpiDetachData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER)
-> ACPI_STATUS;
pub fn AcpiGetData(Object: ACPI_HANDLE, Handler: ACPI_OBJECT_HANDLER,
Data: *mut *mut c_void) -> ACPI_STATUS;
pub fn AcpiDebugTrace(Name: *const i8,
DebugLevel: UINT32, DebugLayer: UINT32,
Flags: UINT32) -> ACPI_STATUS;
pub fn AcpiEvaluateObject(Object: ACPI_HANDLE, Pathname: ACPI_STRING,
ParameterObjects: *mut ACPI_OBJECT_LIST,
ReturnObjectBuffer: *mut ACPI_BUFFER)
-> ACPI_STATUS;
pub fn AcpiEvaluateObjectTyped(Object: ACPI_HANDLE, Pathname: ACPI_STRING,
ExternalParams: *mut ACPI_OBJECT_LIST,
ReturnBuffer: *mut ACPI_BUFFER,
ReturnType: ACPI_OBJECT_TYPE)
-> ACPI_STATUS;
pub fn AcpiGetObjectInfo(Object: ACPI_HANDLE,
ReturnBuffer: *mut *mut ACPI_DEVICE_INFO)
-> ACPI_STATUS;
pub fn AcpiInstallMethod(Buffer: *mut UINT8) -> ACPI_STATUS;
pub fn AcpiGetNextObject(Type: ACPI_OBJECT_TYPE, Parent: ACPI_HANDLE,
Child: ACPI_HANDLE, OutHandle: *mut ACPI_HANDLE)
-> ACPI_STATUS;
pub fn AcpiGetType(Object: ACPI_HANDLE, OutType: *mut ACPI_OBJECT_TYPE)
-> ACPI_STATUS;
pub fn AcpiGetParent(Object: ACPI_HANDLE, OutHandle: *mut ACPI_HANDLE)
-> ACPI_STATUS;
pub fn AcpiInstallInitializationHandler(Handler: ACPI_INIT_HANDLER,
Function: UINT32) -> ACPI_STATUS;
pub fn AcpiInstallSciHandler(Address: ACPI_SCI_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveSciHandler(Address: ACPI_SCI_HANDLER) -> ACPI_STATUS;
pub fn AcpiInstallGlobalEventHandler(Handler: ACPI_GBL_EVENT_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiInstallFixedEventHandler(AcpiEvent: UINT32,
Handler: ACPI_EVENT_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveFixedEventHandler(AcpiEvent: UINT32,
Handler: ACPI_EVENT_HANDLER)
-> ACPI_STATUS;
pub fn AcpiInstallGpeHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
Type: UINT32, Address: ACPI_GPE_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiInstallGpeRawHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
Type: UINT32, Address: ACPI_GPE_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveGpeHandler(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
Address: ACPI_GPE_HANDLER) -> ACPI_STATUS;
pub fn AcpiInstallNotifyHandler(Device: ACPI_HANDLE, HandlerType: UINT32,
Handler: ACPI_NOTIFY_HANDLER,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveNotifyHandler(Device: ACPI_HANDLE, HandlerType: UINT32,
Handler: ACPI_NOTIFY_HANDLER)
-> ACPI_STATUS;
pub fn AcpiInstallAddressSpaceHandler(Device: ACPI_HANDLE,
SpaceId: ACPI_ADR_SPACE_TYPE,
Handler: ACPI_ADR_SPACE_HANDLER,
Setup: ACPI_ADR_SPACE_SETUP,
Context:
*mut c_void)
-> ACPI_STATUS;
pub fn AcpiRemoveAddressSpaceHandler(Device: ACPI_HANDLE,
SpaceId: ACPI_ADR_SPACE_TYPE,
Handler: ACPI_ADR_SPACE_HANDLER)
-> ACPI_STATUS;
pub fn AcpiInstallExceptionHandler(Handler: ACPI_EXCEPTION_HANDLER)
-> ACPI_STATUS;
pub fn AcpiInstallInterfaceHandler(Handler: ACPI_INTERFACE_HANDLER)
-> ACPI_STATUS;
pub fn AcpiAcquireGlobalLock(Timeout: UINT16, Handle: *mut UINT32)
-> ACPI_STATUS;
pub fn AcpiReleaseGlobalLock(Handle: UINT32) -> ACPI_STATUS;
pub fn AcpiAcquireMutex(Handle: ACPI_HANDLE, Pathname: ACPI_STRING,
Timeout: UINT16) -> ACPI_STATUS;
pub fn AcpiReleaseMutex(Handle: ACPI_HANDLE, Pathname: ACPI_STRING)
-> ACPI_STATUS;
pub fn AcpiEnableEvent(Event: UINT32, Flags: UINT32) -> ACPI_STATUS;
pub fn AcpiDisableEvent(Event: UINT32, Flags: UINT32) -> ACPI_STATUS;
pub fn AcpiClearEvent(Event: UINT32) -> ACPI_STATUS;
pub fn AcpiGetEventStatus(Event: UINT32,
EventStatus: *mut ACPI_EVENT_STATUS)
-> ACPI_STATUS;
pub fn AcpiUpdateAllGpes() -> ACPI_STATUS;
pub fn AcpiEnableGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiDisableGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiClearGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiSetGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
Action: UINT8) -> ACPI_STATUS;
pub fn AcpiFinishGpe(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiMarkGpeForWake(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiSetupGpeForWake(ParentDevice: ACPI_HANDLE,
GpeDevice: ACPI_HANDLE, GpeNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiSetGpeWakeMask(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
Action: UINT8) -> ACPI_STATUS;
pub fn AcpiGetGpeStatus(GpeDevice: ACPI_HANDLE, GpeNumber: UINT32,
EventStatus: *mut ACPI_EVENT_STATUS)
-> ACPI_STATUS;
pub fn AcpiDisableAllGpes() -> ACPI_STATUS;
pub fn AcpiEnableAllRuntimeGpes() -> ACPI_STATUS;
pub fn AcpiEnableAllWakeupGpes() -> ACPI_STATUS;
pub fn AcpiGetGpeDevice(GpeIndex: UINT32, GpeDevice: *mut ACPI_HANDLE)
-> ACPI_STATUS;
pub fn AcpiInstallGpeBlock(GpeDevice: ACPI_HANDLE,
GpeBlockAddress: *mut ACPI_GENERIC_ADDRESS,
RegisterCount: UINT32, InterruptNumber: UINT32)
-> ACPI_STATUS;
pub fn AcpiRemoveGpeBlock(GpeDevice: ACPI_HANDLE) -> ACPI_STATUS;
pub fn AcpiGetVendorResource(Device: ACPI_HANDLE,
Name: *mut i8,
Uuid: *mut ACPI_VENDOR_UUID,
RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiGetCurrentResources(Device: ACPI_HANDLE,
RetBuffer: *mut ACPI_BUFFER)
-> ACPI_STATUS;
pub fn AcpiGetPossibleResources(Device: ACPI_HANDLE,
RetBuffer: *mut ACPI_BUFFER)
-> ACPI_STATUS;
pub fn AcpiGetEventResources(DeviceHandle: ACPI_HANDLE,
RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiWalkResourceBuffer(Buffer: *mut ACPI_BUFFER,
UserFunction: ACPI_WALK_RESOURCE_CALLBACK,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiWalkResources(Device: ACPI_HANDLE,
Name: *mut i8,
UserFunction: ACPI_WALK_RESOURCE_CALLBACK,
Context: *mut c_void)
-> ACPI_STATUS;
pub fn AcpiSetCurrentResources(Device: ACPI_HANDLE,
InBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiGetIrqRoutingTable(Device: ACPI_HANDLE,
RetBuffer: *mut ACPI_BUFFER) -> ACPI_STATUS;
pub fn AcpiResourceToAddress64(Resource: *mut ACPI_RESOURCE,
Out: *mut ACPI_RESOURCE_ADDRESS64)
-> ACPI_STATUS;
pub fn AcpiBufferToResource(AmlBuffer: *mut UINT8,
AmlBufferLength: UINT16,
ResourcePtr: *mut *mut ACPI_RESOURCE)
-> ACPI_STATUS;
pub fn AcpiReset() -> ACPI_STATUS;
pub fn AcpiRead(Value: *mut UINT64, Reg: *mut ACPI_GENERIC_ADDRESS)
-> ACPI_STATUS;
pub fn AcpiWrite(Value: UINT64, Reg: *mut ACPI_GENERIC_ADDRESS)
-> ACPI_STATUS;
pub fn AcpiReadBitRegister(RegisterId: UINT32, ReturnValue: *mut UINT32)
-> ACPI_STATUS;
pub fn AcpiWriteBitRegister(RegisterId: UINT32, Value: UINT32)
-> ACPI_STATUS;
pub fn AcpiGetSleepTypeData(SleepState: UINT8, Slp_TypA: *mut UINT8,
Slp_TypB: *mut UINT8) -> ACPI_STATUS;
pub fn AcpiEnterSleepStatePrep(SleepState: UINT8) -> ACPI_STATUS;
pub fn AcpiEnterSleepState(SleepState: UINT8) -> ACPI_STATUS;
pub fn AcpiEnterSleepStateS4bios() -> ACPI_STATUS;
pub fn AcpiLeaveSleepStatePrep(SleepState: UINT8) -> ACPI_STATUS;
pub fn AcpiLeaveSleepState(SleepState: UINT8) -> ACPI_STATUS;
pub fn AcpiSetFirmwareWakingVector(PhysicalAddress: ACPI_PHYSICAL_ADDRESS,
PhysicalAddress64:
ACPI_PHYSICAL_ADDRESS)
-> ACPI_STATUS;
pub fn AcpiGetTimerResolution(Resolution: *mut UINT32) -> ACPI_STATUS;
pub fn AcpiGetTimer(Ticks: *mut UINT32) -> ACPI_STATUS;
pub fn AcpiGetTimerDuration(StartTicks: UINT32, EndTicks: UINT32,
TimeElapsed: *mut UINT32) -> ACPI_STATUS;
pub fn AcpiError(ModuleName: *const i8,
LineNumber: UINT32,
Format: *const i8, ...);
pub fn AcpiException(ModuleName: *const i8,
LineNumber: UINT32, Status: ACPI_STATUS,
Format: *const i8, ...);
pub fn AcpiWarning(ModuleName: *const i8,
LineNumber: UINT32,
Format: *const i8, ...);
pub fn AcpiInfo(Format: *const i8, ...);
pub fn AcpiBiosError(ModuleName: *const i8,
LineNumber: UINT32,
Format: *const i8, ...);
pub fn AcpiBiosWarning(ModuleName: *const i8,
LineNumber: UINT32,
Format: *const i8, ...);
pub fn AcpiInitializeDebugger() -> ACPI_STATUS;
pub fn AcpiTerminateDebugger();
pub fn AcpiSetDebuggerThreadId(ThreadId: UINT64);
}