Vendor dependencies for 0.3.0 release

vendor/io-kit-sys/src/base.rs

@@ -0,0 +1,17 @@
+use std::os::raw::c_uchar;
+
+// exports from `MacTypes.h`
+pub type Boolean = c_uchar;
+
+// exports from `libdispatch`
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct dispatch_queue_s {
+    _address: u8,
+}
+impl Clone for dispatch_queue_s {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type dispatch_queue_t = *mut dispatch_queue_s;

vendor/io-kit-sys/src/hid/base.rs

@@ -0,0 +1,78 @@
+// exports from <IOKit/hid/IOHIDBase.h>
+
+use std::os::raw::c_void;
+
+use core_foundation_sys::base::CFIndex;
+use core_foundation_sys::dictionary::CFDictionaryRef;
+
+use crate::{hid::keys::IOHIDReportType, ret::IOReturn};
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __IOHIDDevice {
+    _unused: [u8; 0],
+}
+pub type IOHIDDeviceRef = *mut __IOHIDDevice;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __IOHIDElement {
+    _unused: [u8; 0],
+}
+pub type IOHIDElementRef = *mut __IOHIDElement;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __IOHIDValue {
+    _unused: [u8; 0],
+}
+pub type IOHIDValueRef = *mut __IOHIDValue;
+
+pub const kIOHIDTransactionDirectionTypeInput: u32 = 0;
+pub const kIOHIDTransactionDirectionTypeOutput: u32 = 1;
+
+pub const kIOHIDTransactionOptionDefaultOutputValue: u32 = 0x0001;
+
+pub type IOHIDCallback =
+    unsafe extern "C" fn(context: *mut c_void, result: IOReturn, sender: *mut c_void);
+
+pub type IOHIDReportCallback = unsafe extern "C" fn(
+    context: *mut c_void,
+    result: IOReturn,
+    sender: *mut c_void,
+    type_: IOHIDReportType,
+    reportID: u32,
+    report: *mut u8,
+    reportLength: CFIndex,
+);
+pub type IOHIDReportWithTimeStampCallback = unsafe extern "C" fn(
+    context: *mut c_void,
+    result: IOReturn,
+    sender: *mut c_void,
+    type_: IOHIDReportType,
+    reportID: u32,
+    report: *mut u8,
+    reportLength: CFIndex,
+    timeStamp: u64,
+);
+
+pub type IOHIDValueCallback = unsafe extern "C" fn(
+    context: *mut c_void,
+    result: IOReturn,
+    sender: *mut c_void,
+    value: IOHIDValueRef,
+);
+
+pub type IOHIDValueMultipleCallback = unsafe extern "C" fn(
+    context: *mut c_void,
+    result: IOReturn,
+    sender: *mut c_void,
+    multiple: CFDictionaryRef,
+);
+
+pub type IOHIDDeviceCallback = unsafe extern "C" fn(
+    context: *mut c_void,
+    result: IOReturn,
+    sender: *mut c_void,
+    device: IOHIDDeviceRef,
+);

vendor/io-kit-sys/src/hid/device.rs

@@ -0,0 +1,192 @@
+// exports from <IOKit/hid/IOHIDDevice.h>
+
+use std::os::raw::c_void;
+
+use core_foundation_sys::array::CFArrayRef;
+use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFTypeID, CFTypeRef};
+use core_foundation_sys::date::CFTimeInterval;
+use core_foundation_sys::dictionary::CFDictionaryRef;
+use core_foundation_sys::runloop::CFRunLoopRef;
+use core_foundation_sys::string::CFStringRef;
+
+use crate::{
+    base::Boolean,
+    hid::{
+        base::{
+            IOHIDCallback, IOHIDDeviceRef, IOHIDElementRef, IOHIDReportCallback,
+            IOHIDReportWithTimeStampCallback, IOHIDValueCallback, IOHIDValueMultipleCallback,
+            IOHIDValueRef,
+        },
+        keys::IOHIDReportType,
+    },
+    ret::IOReturn,
+    types::{io_service_t, IOOptionBits},
+};
+
+extern "C" {
+    pub fn IOHIDDeviceGetTypeID() -> CFTypeID;
+
+    pub fn IOHIDDeviceCreate(allocator: CFAllocatorRef, service: io_service_t) -> IOHIDDeviceRef;
+
+    pub fn IOHIDDeviceGetService(device: IOHIDDeviceRef) -> io_service_t;
+
+    pub fn IOHIDDeviceOpen(device: IOHIDDeviceRef, options: IOOptionBits) -> IOReturn;
+
+    pub fn IOHIDDeviceClose(device: IOHIDDeviceRef, options: IOOptionBits) -> IOReturn;
+
+    pub fn IOHIDDeviceConformsTo(device: IOHIDDeviceRef, usagePage: u32, usage: u32) -> Boolean;
+
+    pub fn IOHIDDeviceGetProperty(device: IOHIDDeviceRef, key: CFStringRef) -> CFTypeRef;
+
+    pub fn IOHIDDeviceSetProperty(
+        device: IOHIDDeviceRef,
+        key: CFStringRef,
+        property: CFTypeRef,
+    ) -> Boolean;
+
+    pub fn IOHIDDeviceCopyMatchingElements(
+        device: IOHIDDeviceRef,
+        matching: CFDictionaryRef,
+        options: IOOptionBits,
+    ) -> CFArrayRef;
+
+    pub fn IOHIDDeviceScheduleWithRunLoop(
+        device: IOHIDDeviceRef,
+        runLoop: CFRunLoopRef,
+        runLoopMode: CFStringRef,
+    );
+
+    pub fn IOHIDDeviceUnscheduleFromRunLoop(
+        device: IOHIDDeviceRef,
+        runLoop: CFRunLoopRef,
+        runLoopMode: CFStringRef,
+    );
+
+    pub fn IOHIDDeviceRegisterRemovalCallback(
+        device: IOHIDDeviceRef,
+        callback: IOHIDCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDDeviceRegisterInputValueCallback(
+        device: IOHIDDeviceRef,
+        callback: IOHIDValueCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDDeviceRegisterInputReportCallback(
+        device: IOHIDDeviceRef,
+        report: *mut u8,
+        reportLength: CFIndex,
+        callback: IOHIDReportCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDDeviceRegisterInputReportWithTimeStampCallback(
+        device: IOHIDDeviceRef,
+        report: *mut u8,
+        reportLength: CFIndex,
+        callback: IOHIDReportWithTimeStampCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDDeviceSetInputValueMatching(device: IOHIDDeviceRef, matching: CFDictionaryRef);
+
+    pub fn IOHIDDeviceSetInputValueMatchingMultiple(device: IOHIDDeviceRef, multiple: CFArrayRef);
+
+    pub fn IOHIDDeviceSetValue(
+        device: IOHIDDeviceRef,
+        element: IOHIDElementRef,
+        value: IOHIDValueRef,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceSetValueMultiple(
+        device: IOHIDDeviceRef,
+        multiple: CFDictionaryRef,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceSetValueWithCallback(
+        device: IOHIDDeviceRef,
+        element: IOHIDElementRef,
+        value: IOHIDValueRef,
+        timeout: CFTimeInterval,
+        callback: IOHIDValueCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceSetValueMultipleWithCallback(
+        device: IOHIDDeviceRef,
+        multiple: CFDictionaryRef,
+        timeout: CFTimeInterval,
+        callback: IOHIDValueMultipleCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceGetValue(
+        device: IOHIDDeviceRef,
+        element: IOHIDElementRef,
+        pValue: *mut IOHIDValueRef,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceCopyValueMultiple(
+        device: IOHIDDeviceRef,
+        elements: CFArrayRef,
+        pMultiple: *mut CFDictionaryRef,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceGetValueWithCallback(
+        device: IOHIDDeviceRef,
+        element: IOHIDElementRef,
+        pValue: *mut IOHIDValueRef,
+        timeout: CFTimeInterval,
+        callback: IOHIDValueCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceCopyValueMultipleWithCallback(
+        device: IOHIDDeviceRef,
+        elements: CFArrayRef,
+        pMultiple: *mut CFDictionaryRef,
+        timeout: CFTimeInterval,
+        callback: IOHIDValueMultipleCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceSetReport(
+        device: IOHIDDeviceRef,
+        reportType: IOHIDReportType,
+        reportID: CFIndex,
+        report: *const u8,
+        reportLength: CFIndex,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceSetReportWithCallback(
+        device: IOHIDDeviceRef,
+        reportType: IOHIDReportType,
+        reportID: CFIndex,
+        report: *const u8,
+        reportLength: CFIndex,
+        timeout: CFTimeInterval,
+        callback: IOHIDReportCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceGetReport(
+        device: IOHIDDeviceRef,
+        reportType: IOHIDReportType,
+        reportID: CFIndex,
+        report: *mut u8,
+        pReportLength: *mut CFIndex,
+    ) -> IOReturn;
+
+    pub fn IOHIDDeviceGetReportWithCallback(
+        device: IOHIDDeviceRef,
+        reportType: IOHIDReportType,
+        reportID: CFIndex,
+        report: *mut u8,
+        pReportLength: *mut CFIndex,
+        timeout: CFTimeInterval,
+        callback: IOHIDReportCallback,
+        context: *mut c_void,
+    ) -> IOReturn;
+}

vendor/io-kit-sys/src/hid/element.rs

@@ -0,0 +1,87 @@
+// exports from <IOKit/hid/IOHIDElement.h>
+
+use core_foundation_sys::array::CFArrayRef;
+use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFTypeID, CFTypeRef};
+use core_foundation_sys::dictionary::CFDictionaryRef;
+use core_foundation_sys::string::CFStringRef;
+
+use crate::{
+    base::Boolean,
+    hid::{
+        base::{IOHIDDeviceRef, IOHIDElementRef},
+        keys::{IOHIDElementCollectionType, IOHIDElementCookie, IOHIDElementType},
+    },
+};
+
+extern "C" {
+    pub fn IOHIDElementGetTypeID() -> CFTypeID;
+
+    pub fn IOHIDElementCreateWithDictionary(
+        allocator: CFAllocatorRef,
+        dictionary: CFDictionaryRef,
+    ) -> IOHIDElementRef;
+
+    pub fn IOHIDElementGetDevice(element: IOHIDElementRef) -> IOHIDDeviceRef;
+
+    pub fn IOHIDElementGetParent(element: IOHIDElementRef) -> IOHIDElementRef;
+
+    pub fn IOHIDElementGetChildren(element: IOHIDElementRef) -> CFArrayRef;
+
+    pub fn IOHIDElementAttach(element: IOHIDElementRef, toAttach: IOHIDElementRef);
+
+    pub fn IOHIDElementDetach(element: IOHIDElementRef, toDetach: IOHIDElementRef);
+
+    pub fn IOHIDElementCopyAttached(element: IOHIDElementRef) -> CFArrayRef;
+
+    pub fn IOHIDElementGetCookie(element: IOHIDElementRef) -> IOHIDElementCookie;
+
+    pub fn IOHIDElementGetType(element: IOHIDElementRef) -> IOHIDElementType;
+
+    pub fn IOHIDElementGetCollectionType(element: IOHIDElementRef) -> IOHIDElementCollectionType;
+
+    pub fn IOHIDElementGetUsagePage(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetUsage(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementIsVirtual(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementIsRelative(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementIsWrapping(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementIsArray(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementIsNonLinear(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementHasPreferredState(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementHasNullState(element: IOHIDElementRef) -> Boolean;
+
+    pub fn IOHIDElementGetName(element: IOHIDElementRef) -> CFStringRef;
+
+    pub fn IOHIDElementGetReportID(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetReportSize(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetReportCount(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetUnit(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetUnitExponent(element: IOHIDElementRef) -> u32;
+
+    pub fn IOHIDElementGetLogicalMin(element: IOHIDElementRef) -> CFIndex;
+
+    pub fn IOHIDElementGetLogicalMax(element: IOHIDElementRef) -> CFIndex;
+
+    pub fn IOHIDElementGetPhysicalMin(element: IOHIDElementRef) -> CFIndex;
+
+    pub fn IOHIDElementGetPhysicalMax(element: IOHIDElementRef) -> CFIndex;
+
+    pub fn IOHIDElementGetProperty(element: IOHIDElementRef, key: CFStringRef) -> CFTypeRef;
+
+    pub fn IOHIDElementSetProperty(
+        element: IOHIDElementRef,
+        key: CFStringRef,
+        property: CFTypeRef,
+    ) -> Boolean;
+}

vendor/io-kit-sys/src/hid/keys.rs

@@ -0,0 +1,250 @@
+// exports from <IOKit/hid/IOHIDKeys.h>
+
+// This is used to find HID Devices in the IORegistry
+pub const kIOHIDDeviceKey: *const ::std::os::raw::c_char =
+    b"IOHIDDevice\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+
+// HID Device Property Keys
+pub const kIOHIDTransportKey: *const ::std::os::raw::c_char =
+    b"Transport\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDVendorIDKey: *const ::std::os::raw::c_char =
+    b"VendorID\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDVendorIDSourceKey: *const ::std::os::raw::c_char =
+    b"VendorIDSource\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDProductIDKey: *const ::std::os::raw::c_char =
+    b"ProductID\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDVersionNumberKey: *const ::std::os::raw::c_char =
+    b"VersionNumber\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDManufacturerKey: *const ::std::os::raw::c_char =
+    b"Manufacturer\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDProductKey: *const ::std::os::raw::c_char =
+    b"Product\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDSerialNumberKey: *const ::std::os::raw::c_char =
+    b"SerialNumber\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDCountryCodeKey: *const ::std::os::raw::c_char =
+    b"CountryCode\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDStandardTypeKey: *const ::std::os::raw::c_char =
+    b"StandardType\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDLocationIDKey: *const ::std::os::raw::c_char =
+    b"LocationID\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDDeviceUsageKey: *const ::std::os::raw::c_char =
+    b"DeviceUsage\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDDeviceUsagePageKey: *const ::std::os::raw::c_char =
+    b"DeviceUsagePage\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDDeviceUsagePairsKey: *const ::std::os::raw::c_char =
+    b"DeviceUsagePairs\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDPrimaryUsageKey: *const ::std::os::raw::c_char =
+    b"PrimaryUsage\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDPrimaryUsagePageKey: *const ::std::os::raw::c_char =
+    b"PrimaryUsagePage\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDMaxInputReportSizeKey: *const ::std::os::raw::c_char =
+    b"MaxInputReportSize\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDMaxOutputReportSizeKey: *const ::std::os::raw::c_char =
+    b"MaxOutputReportSize\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDMaxFeatureReportSizeKey: *const ::std::os::raw::c_char =
+    b"MaxFeatureReportSize\x00" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDReportIntervalKey: *const ::std::os::raw::c_char =
+    b"ReportInterval\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDSampleIntervalKey: *const ::std::os::raw::c_char =
+    b"SampleInterval\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDBatchIntervalKey: *const ::std::os::raw::c_char =
+    b"BatchInterval\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDRequestTimeoutKey: *const ::std::os::raw::c_char =
+    b"RequestTimeout\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDReportDescriptorKey: *const ::std::os::raw::c_char =
+    b"ReportDescriptor\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDResetKey: *const ::std::os::raw::c_char =
+    b"Reset\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDKeyboardLanguageKey: *const ::std::os::raw::c_char =
+    b"KeyboardLanguage\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDAltHandlerIdKey: *const ::std::os::raw::c_char =
+    b"alt_handler_id\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDBuiltInKey: *const ::std::os::raw::c_char =
+    b"Built-In\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDDisplayIntegratedKey: *const ::std::os::raw::c_char =
+    b"DisplayIntegrated\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDProductIDMaskKey: *const ::std::os::raw::c_char =
+    b"ProductIDMask\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDProductIDArrayKey: *const ::std::os::raw::c_char =
+    b"ProductIDArray\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDPowerOnDelayNSKey: *const ::std::os::raw::c_char =
+    b"HIDPowerOnDelayNS\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDCategoryKey: *const ::std::os::raw::c_char =
+    b"Category\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDMaxResponseLatencyKey: *const ::std::os::raw::c_char =
+    b"MaxResponseLatency\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDUniqueIDKey: *const ::std::os::raw::c_char =
+    b"UniqueID\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDPhysicalDeviceUniqueIDKey: *const ::std::os::raw::c_char =
+    b"PhysicalDeviceUniqueID\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+pub const kIOHIDTransportUSBValue: *const ::std::os::raw::c_char =
+    b"USB\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportBluetoothValue: *const ::std::os::raw::c_char =
+    b"Bluetooth\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportBluetoothLowEnergyValue: *const ::std::os::raw::c_char =
+    b"BluetoothLowEnergy\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportAIDBValue: *const ::std::os::raw::c_char =
+    b"AIDB\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportI2CValue: *const ::std::os::raw::c_char =
+    b"I2C\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportSPIValue: *const ::std::os::raw::c_char =
+    b"SPI\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportSerialValue: *const ::std::os::raw::c_char =
+    b"Serial\x00" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportIAPValue: *const ::std::os::raw::c_char =
+    b"IAP\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportAirPlayValue: *const ::std::os::raw::c_char =
+    b"AirPlay\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDTransportSPUValue: *const ::std::os::raw::c_char =
+    b"SPU\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+
+pub const kIOHIDCategoryAutomotiveValue: *const ::std::os::raw::c_char =
+    b"Automotive\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+
+// HID Element Key
+pub const kIOHIDElementKey: *const ::std::os::raw::c_char =
+    b"Elements\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+
+// HID Element Dictionary Keys
+pub const kIOHIDElementCookieKey: *const ::std::os::raw::c_char =
+    b"ElementCookie\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementTypeKey: *const ::std::os::raw::c_char =
+    b"Type\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCollectionTypeKey: *const ::std::os::raw::c_char =
+    b"CollectionType\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUsageKey: *const ::std::os::raw::c_char =
+    b"Usage\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUsagePageKey: *const ::std::os::raw::c_char =
+    b"UsagePage\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementMinKey: *const ::std::os::raw::c_char =
+    b"Min\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementMaxKey: *const ::std::os::raw::c_char =
+    b"Max\x00" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementScaledMinKey: *const ::std::os::raw::c_char =
+    b"ScaledMin\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementScaledMaxKey: *const ::std::os::raw::c_char =
+    b"ScaledMax\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementSizeKey: *const ::std::os::raw::c_char =
+    b"Size\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementReportSizeKey: *const ::std::os::raw::c_char =
+    b"ReportSize\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementReportCountKey: *const ::std::os::raw::c_char =
+    b"ReportCount\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementReportIDKey: *const ::std::os::raw::c_char =
+    b"ReportID\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementIsArrayKey: *const ::std::os::raw::c_char =
+    b"IsArray\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementIsRelativeKey: *const ::std::os::raw::c_char =
+    b"IsRelative\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementIsWrappingKey: *const ::std::os::raw::c_char =
+    b"IsWrapping\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementIsNonLinearKey: *const ::std::os::raw::c_char =
+    b"IsNonLinear\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementHasPreferredStateKey: *const ::std::os::raw::c_char =
+    b"HasPreferredState\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementHasNullStateKey: *const ::std::os::raw::c_char =
+    b"HasNullState\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementFlagsKey: *const ::std::os::raw::c_char =
+    b"Flags\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUnitKey: *const ::std::os::raw::c_char =
+    b"Unit\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUnitExponentKey: *const ::std::os::raw::c_char =
+    b"UnitExponent\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementNameKey: *const ::std::os::raw::c_char =
+    b"Name\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementValueLocationKey: *const ::std::os::raw::c_char =
+    b"ValueLocation\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementDuplicateIndexKey: *const ::std::os::raw::c_char =
+    b"DuplicateIndex\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementParentCollectionKey: *const ::std::os::raw::c_char =
+    b"ParentCollection\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementVendorSpecificKey: *const ::std::os::raw::c_char =
+    b"VendorSpecific\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+
+// HID Element Match Keys
+pub const kIOHIDElementCookieMinKey: *const ::std::os::raw::c_char =
+    b"ElementCookieMin\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCookieMaxKey: *const ::std::os::raw::c_char =
+    b"ElementCookieMax\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUsageMinKey: *const ::std::os::raw::c_char =
+    b"UsageMin\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementUsageMaxKey: *const ::std::os::raw::c_char =
+    b"UsageMax\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+
+// HID Element Calibration Keys
+pub const kIOHIDElementCalibrationMinKey: *const ::std::os::raw::c_char =
+    b"CalibrationMin\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationMaxKey: *const ::std::os::raw::c_char =
+    b"CalibrationMax\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationSaturationMinKey: *const ::std::os::raw::c_char =
+    b"CalibrationSaturationMin\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationSaturationMaxKey: *const ::std::os::raw::c_char =
+    b"CalibrationSaturationMax\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationDeadZoneMinKey: *const ::std::os::raw::c_char =
+    b"CalibrationDeadZoneMin\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationDeadZoneMaxKey: *const ::std::os::raw::c_char =
+    b"CalibrationDeadZoneMax\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOHIDElementCalibrationGranularityKey: *const ::std::os::raw::c_char =
+    b"CalibrationGranularity\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+pub type IOHIDElementCookie = u32;
+
+pub type IOHIDElementType = u32;
+pub const kIOHIDElementTypeInput_Misc: IOHIDElementType = 1;
+pub const kIOHIDElementTypeInput_Button: IOHIDElementType = 2;
+pub const kIOHIDElementTypeInput_Axis: IOHIDElementType = 3;
+pub const kIOHIDElementTypeInput_ScanCodes: IOHIDElementType = 4;
+pub const kIOHIDElementTypeOutput: IOHIDElementType = 129;
+pub const kIOHIDElementTypeFeature: IOHIDElementType = 257;
+pub const kIOHIDElementTypeCollection: IOHIDElementType = 513;
+
+pub type IOHIDElementCollectionType = u32;
+pub const kIOHIDElementCollectionTypePhysical: IOHIDElementCollectionType = 0x00;
+pub const kIOHIDElementCollectionTypeApplication: IOHIDElementCollectionType = 0x01;
+pub const kIOHIDElementCollectionTypeLogical: IOHIDElementCollectionType = 0x02;
+pub const kIOHIDElementCollectionTypeReport: IOHIDElementCollectionType = 0x03;
+pub const kIOHIDElementCollectionTypeNamedArray: IOHIDElementCollectionType = 0x04;
+pub const kIOHIDElementCollectionTypeUsageSwitch: IOHIDElementCollectionType = 0x05;
+pub const kIOHIDElementCollectionTypeUsageModifier: IOHIDElementCollectionType = 0x06;
+
+pub type IOHIDReportType = u32;
+pub const kIOHIDReportTypeInput: IOHIDReportType = 0;
+pub const kIOHIDReportTypeOutput: IOHIDReportType = 1;
+pub const kIOHIDReportTypeFeature: IOHIDReportType = 2;
+pub const kIOHIDReportTypeCount: IOHIDReportType = 3;
+
+pub type IOHIDOptionsType = u32;
+pub const kIOHIDOptionsTypeNone: IOHIDOptionsType = 0x00;
+pub const kIOHIDOptionsTypeSeizeDevice: IOHIDOptionsType = 0x01;
+
+pub type IOHIDQueueOptionsType = u32;
+pub const kIOHIDQueueOptionsTypeNone: IOHIDQueueOptionsType = 0x00;
+pub const kIOHIDQueueOptionsTypeEnqueueAll: IOHIDQueueOptionsType = 0x01;
+
+pub type IOHIDElementFlags = u32;
+pub const kIOHIDElementFlagsConstantMask: IOHIDElementFlags = 0x0001;
+pub const kIOHIDElementFlagsVariableMask: IOHIDElementFlags = 0x0002;
+pub const kIOHIDElementFlagsRelativeMask: IOHIDElementFlags = 0x0004;
+pub const kIOHIDElementFlagsWrapMask: IOHIDElementFlags = 0x0008;
+pub const kIOHIDElementFlagsNonLinearMask: IOHIDElementFlags = 0x0010;
+pub const kIOHIDElementFlagsNoPreferredMask: IOHIDElementFlags = 0x0020;
+pub const kIOHIDElementFlagsNullStateMask: IOHIDElementFlags = 0x0040;
+pub const kIOHIDElementFlagsVolativeMask: IOHIDElementFlags = 0x0080;
+pub const kIOHIDElementFlagsBufferedByteMask: IOHIDElementFlags = 0x0100;
+
+pub type IOHIDStandardType = u32;
+pub const kIOHIDStandardTypeANSI: IOHIDStandardType = 0;
+pub const kIOHIDStandardTypeISO: IOHIDStandardType = 1;
+pub const kIOHIDStandardTypeJIS: IOHIDStandardType = 2;
+
+pub type IOHIDValueScaleType = u32;
+pub const kIOHIDValueScaleTypeCalibrated: IOHIDValueScaleType = 0;
+pub const kIOHIDValueScaleTypePhysical: IOHIDValueScaleType = 1;
+
+pub type IOHIDValueOptions = u32;
+pub const kIOHIDValueOptionsFlagRelativeSimple: IOHIDValueOptions = 1 << 0;
+pub const kIOHIDValueOptionsFlagPrevious: IOHIDValueOptions = 1 << 1;
+
+pub const kIOHIDDigitizerGestureCharacterStateKey: *const ::std::os::raw::c_char =
+    b"DigitizerCharacterGestureState\x00" as *const [u8; 31usize] as *const ::std::os::raw::c_char;

vendor/io-kit-sys/src/hid/manager.rs

@@ -0,0 +1,108 @@
+// exports from <IOKit/hid/IOHIDManager.h>
+
+use std::os::raw::c_void;
+
+use core_foundation_sys::array::CFArrayRef;
+use core_foundation_sys::base::{CFAllocatorRef, CFTypeID, CFTypeRef};
+use core_foundation_sys::dictionary::CFDictionaryRef;
+use core_foundation_sys::runloop::CFRunLoopRef;
+use core_foundation_sys::set::CFSetRef;
+use core_foundation_sys::string::CFStringRef;
+
+use crate::{
+    base::Boolean,
+    hid::base::{IOHIDDeviceCallback, IOHIDReportCallback, IOHIDValueCallback},
+    ret::IOReturn,
+    types::IOOptionBits,
+};
+
+pub type IOHIDManagerOptions = IOOptionBits;
+pub const kIOHIDManagerOptionNone: IOHIDManagerOptions = 0x0;
+pub const kIOHIDManagerOptionUsePersistentProperties: IOHIDManagerOptions = 0x1;
+pub const kIOHIDManagerOptionDoNotLoadProperties: IOHIDManagerOptions = 0x2;
+pub const kIOHIDManagerOptionDoNotSaveProperties: IOHIDManagerOptions = 0x4;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __IOHIDManager {
+    _unused: [u8; 0],
+}
+pub type IOHIDManagerRef = *mut __IOHIDManager;
+
+extern "C" {
+    pub fn IOHIDManagerGetTypeID() -> CFTypeID;
+
+    pub fn IOHIDManagerCreate(
+        allocator: CFAllocatorRef,
+        options: IOHIDManagerOptions,
+    ) -> IOHIDManagerRef;
+
+    pub fn IOHIDManagerOpen(manager: IOHIDManagerRef, options: IOHIDManagerOptions) -> IOReturn;
+
+    pub fn IOHIDManagerClose(manager: IOHIDManagerRef, options: IOHIDManagerOptions) -> IOReturn;
+
+    pub fn IOHIDManagerGetProperty(manager: IOHIDManagerRef, key: CFStringRef) -> CFTypeRef;
+
+    pub fn IOHIDManagerSetProperty(
+        manager: IOHIDManagerRef,
+        key: CFStringRef,
+        value: CFTypeRef,
+    ) -> Boolean;
+
+    pub fn IOHIDManagerScheduleWithRunLoop(
+        manager: IOHIDManagerRef,
+        runLoop: CFRunLoopRef,
+        runLoopMode: CFStringRef,
+    );
+
+    pub fn IOHIDManagerUnscheduleFromRunLoop(
+        manager: IOHIDManagerRef,
+        runLoop: CFRunLoopRef,
+        runLoopMode: CFStringRef,
+    );
+
+    pub fn IOHIDManagerSetDeviceMatching(manager: IOHIDManagerRef, matching: CFDictionaryRef);
+
+    pub fn IOHIDManagerSetDeviceMatchingMultiple(manager: IOHIDManagerRef, multiple: CFArrayRef);
+
+    pub fn IOHIDManagerCopyDevices(manager: IOHIDManagerRef) -> CFSetRef;
+
+    pub fn IOHIDManagerRegisterDeviceMatchingCallback(
+        manager: IOHIDManagerRef,
+        callback: IOHIDDeviceCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDManagerRegisterDeviceRemovalCallback(
+        manager: IOHIDManagerRef,
+        callback: IOHIDDeviceCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDManagerRegisterInputReportCallback(
+        manager: IOHIDManagerRef,
+        callback: IOHIDReportCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDManagerRegisterInputValueCallback(
+        manager: IOHIDManagerRef,
+        callback: IOHIDValueCallback,
+        context: *mut c_void,
+    );
+
+    pub fn IOHIDManagerSetInputValueMatching(manager: IOHIDManagerRef, matching: CFDictionaryRef);
+
+    pub fn IOHIDManagerSetInputValueMatchingMultiple(
+        manager: IOHIDManagerRef,
+        multiple: CFArrayRef,
+    );
+
+    pub fn IOHIDManagerSaveToPropertyDomain(
+        manager: IOHIDManagerRef,
+        applicationID: CFStringRef,
+        userName: CFStringRef,
+        hostName: CFStringRef,
+        options: IOOptionBits,
+    );
+}

vendor/io-kit-sys/src/hid/mod.rs

@@ -0,0 +1,7 @@
+pub mod base;
+pub mod device;
+pub mod element;
+pub mod keys;
+pub mod manager;
+pub mod usage_tables;
+pub mod value;

vendor/io-kit-sys/src/hid/value.rs

@@ -0,0 +1,47 @@
+// exports from <IOKit/hid/IOHIDValue.h>
+
+use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFTypeID};
+
+use crate::hid::{
+    base::{IOHIDElementRef, IOHIDValueRef},
+    keys::IOHIDValueScaleType
+};
+
+extern "C" {
+    pub fn IOHIDValueGetTypeID() -> CFTypeID;
+
+    pub fn IOHIDValueCreateWithIntegerValue(
+        allocator: CFAllocatorRef,
+        element: IOHIDElementRef,
+        timeStamp: u64,
+        value: CFIndex,
+    ) -> IOHIDValueRef;
+
+    pub fn IOHIDValueCreateWithBytes(
+        allocator: CFAllocatorRef,
+        element: IOHIDElementRef,
+        timeStamp: u64,
+        bytes: *const u8,
+        length: CFIndex,
+    ) -> IOHIDValueRef;
+
+    pub fn IOHIDValueCreateWithBytesNoCopy(
+        allocator: CFAllocatorRef,
+        element: IOHIDElementRef,
+        timeStamp: u64,
+        bytes: *const u8,
+        length: CFIndex,
+    ) -> IOHIDValueRef;
+
+    pub fn IOHIDValueGetElement(value: IOHIDValueRef) -> IOHIDElementRef;
+
+    pub fn IOHIDValueGetTimeStamp(value: IOHIDValueRef) -> u64;
+
+    pub fn IOHIDValueGetLength(value: IOHIDValueRef) -> CFIndex;
+
+    pub fn IOHIDValueGetBytePtr(value: IOHIDValueRef) -> *const u8;
+
+    pub fn IOHIDValueGetIntegerValue(value: IOHIDValueRef) -> CFIndex;
+
+    pub fn IOHIDValueGetScaledValue(value: IOHIDValueRef, type_: IOHIDValueScaleType) -> f64;
+}

vendor/io-kit-sys/src/keys.rs

@@ -0,0 +1,192 @@
+// exports from <IOKit/IOKitKeys.h>
+
+// properties found in the registry root
+pub const kIOKitBuildVersionKey: *const ::std::os::raw::c_char =
+    b"IOKitBuildVersion\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOKitDiagnosticsKey: *const ::std::os::raw::c_char =
+    b"IOKitDiagnostics\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+// a dictionary keyed by plane name
+pub const kIORegistryPlanesKey: *const ::std::os::raw::c_char =
+    b"IORegistryPlanes\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOCatalogueKey: *const ::std::os::raw::c_char =
+    b"IOCatalogue\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+
+// registry plane names
+pub const kIOServicePlane: *const ::std::os::raw::c_char =
+    b"IOService\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOPowerPlane: *const ::std::os::raw::c_char =
+    b"IOPower\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIODeviceTreePlane: *const ::std::os::raw::c_char =
+    b"IODeviceTree\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOAudioPlane: *const ::std::os::raw::c_char =
+    b"IOAudio\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOFireWirePlane: *const ::std::os::raw::c_char =
+    b"IOFireWire\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOUSBPlane: *const ::std::os::raw::c_char =
+    b"IOUSB\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+
+// registry ID number
+pub const kIORegistryEntryIDKey: *const ::std::os::raw::c_char =
+    b"IORegistryEntryID\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+
+// IOService class name
+pub const kIOServiceClass: *const ::std::os::raw::c_char =
+    b"IOService\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+
+// IOResources class name
+pub const kIOResourcesClass: *const ::std::os::raw::c_char =
+    b"IOResources\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+
+// IOService driver probing property names
+pub const kIOClassKey: *const ::std::os::raw::c_char =
+    b"IOClass\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOProbeScoreKey: *const ::std::os::raw::c_char =
+    b"IOProbeScore\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOKitDebugKey: *const ::std::os::raw::c_char =
+    b"IOKitDebug\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+
+// IOService matching property names
+pub const kIOProviderClassKey: *const ::std::os::raw::c_char =
+    b"IOProviderClass\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIONameMatchKey: *const ::std::os::raw::c_char =
+    b"IONameMatch\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPropertyMatchKey: *const ::std::os::raw::c_char =
+    b"IOPropertyMatch\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPathMatchKey: *const ::std::os::raw::c_char =
+    b"IOPathMatch\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOLocationMatchKey: *const ::std::os::raw::c_char =
+    b"IOLocationMatch\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOParentMatchKey: *const ::std::os::raw::c_char =
+    b"IOParentMatch\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOResourceMatchKey: *const ::std::os::raw::c_char =
+    b"IOResourceMatch\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOMatchedServiceCountKey: *const ::std::os::raw::c_char =
+    b"IOMatchedServiceCountMatch\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+
+pub const kIONameMatchedKey: *const ::std::os::raw::c_char =
+    b"IONameMatched\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+
+pub const kIOMatchCategoryKey: *const ::std::os::raw::c_char =
+    b"IOMatchCategory\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIODefaultMatchCategoryKey: *const ::std::os::raw::c_char =
+    b"IODefaultMatchCategory\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+// IOService default user client class, for loadable user clients
+pub const kIOUserClientClassKey: *const ::std::os::raw::c_char =
+    b"IOUserClientClass\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+
+// key to find IOMappers
+pub const kIOMapperIDKey: *const ::std::os::raw::c_char =
+    b"IOMapperID\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+
+pub const kIOUserClientCrossEndianKey: *const ::std::os::raw::c_char =
+    b"IOUserClientCrossEndian\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIOUserClientCrossEndianCompatibleKey: *const ::std::os::raw::c_char =
+    b"IOUserClientCrossEndianCompatible\x00" as *const [u8; 34usize]
+        as *const ::std::os::raw::c_char;
+pub const kIOUserClientSharedInstanceKey: *const ::std::os::raw::c_char =
+    b"IOUserClientSharedInstance\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+// diagnostic string describing the creating task
+pub const kIOUserClientCreatorKey: *const ::std::os::raw::c_char =
+    b"IOUserClientCreator\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+
+// IOService notification types
+pub const kIOPublishNotification: *const ::std::os::raw::c_char =
+    b"IOServicePublish\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOFirstPublishNotification: *const ::std::os::raw::c_char =
+    b"IOServiceFirstPublish\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOMatchedNotification: *const ::std::os::raw::c_char =
+    b"IOServiceMatched\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOFirstMatchNotification: *const ::std::os::raw::c_char =
+    b"IOServiceFirstMatch\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOTerminatedNotification: *const ::std::os::raw::c_char =
+    b"IOServiceTerminate\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+
+// IOService interest notification types
+pub const kIOGeneralInterest: *const ::std::os::raw::c_char =
+    b"IOGeneralInterest\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOBusyInterest: *const ::std::os::raw::c_char =
+    b"IOBusyInterest\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOAppPowerStateInterest: *const ::std::os::raw::c_char =
+    b"IOAppPowerStateInterest\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIOPriorityPowerStateInterest: *const ::std::os::raw::c_char =
+    b"IOPriorityPowerStateInterest\x00" as *const [u8; 29usize] as *const ::std::os::raw::c_char;
+
+pub const kIOPlatformDeviceMessageKey: *const ::std::os::raw::c_char =
+    b"IOPlatformDeviceMessage\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+
+// IOService interest notification types
+pub const kIOCFPlugInTypesKey: *const ::std::os::raw::c_char =
+    b"IOCFPlugInTypes\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+
+// properties found in services that implement command pooling
+pub const kIOCommandPoolSizeKey: *const ::std::os::raw::c_char =
+    b"IOCommandPoolSize\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+
+// properties found in services that implement priority
+pub const kIOMaximumPriorityCountKey: *const ::std::os::raw::c_char =
+    b"IOMaximumPriorityCount\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+// properties found in services that have transfer constraints
+pub const kIOMaximumBlockCountReadKey: *const ::std::os::raw::c_char =
+    b"IOMaximumBlockCountRead\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumBlockCountWriteKey: *const ::std::os::raw::c_char =
+    b"IOMaximumBlockCountWrite\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumByteCountReadKey: *const ::std::os::raw::c_char =
+    b"IOMaximumByteCountRead\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumByteCountWriteKey: *const ::std::os::raw::c_char =
+    b"IOMaximumByteCountWrite\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumSegmentCountReadKey: *const ::std::os::raw::c_char =
+    b"IOMaximumSegmentCountRead\x00" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumSegmentCountWriteKey: *const ::std::os::raw::c_char =
+    b"IOMaximumSegmentCountWrite\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumSegmentByteCountReadKey: *const ::std::os::raw::c_char =
+    b"IOMaximumSegmentByteCountRead\x00" as *const [u8; 30usize] as *const ::std::os::raw::c_char;
+pub const kIOMaximumSegmentByteCountWriteKey: *const ::std::os::raw::c_char =
+    b"IOMaximumSegmentByteCountWrite\x00" as *const [u8; 31usize] as *const ::std::os::raw::c_char;
+pub const kIOMinimumSegmentAlignmentByteCountKey: *const ::std::os::raw::c_char =
+    b"IOMinimumSegmentAlignmentByteCount\x00" as *const [u8; 35usize]
+        as *const ::std::os::raw::c_char;
+pub const kIOMaximumSegmentAddressableBitCountKey: *const ::std::os::raw::c_char =
+    b"IOMaximumSegmentAddressableBitCount\x00" as *const [u8; 36usize]
+        as *const ::std::os::raw::c_char;
+
+// properties found in services that wish to describe an icon
+pub const kIOIconKey: *const ::std::os::raw::c_char =
+    b"IOIcon\x00" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOBundleResourceFileKey: *const ::std::os::raw::c_char =
+    b"IOBundleResourceFile\x00" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOBusBadgeKey: *const ::std::os::raw::c_char =
+    b"IOBusBadge\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIODeviceIconKey: *const ::std::os::raw::c_char =
+    b"IODeviceIcon\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+
+// property of root that describes the machine's serial number as a string
+pub const kIOPlatformSerialNumberKey: *const ::std::os::raw::c_char =
+    b"IOPlatformSerialNumber\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+// property of root that describes the machine's UUID as a string
+pub const kIOPlatformUUIDKey: *const ::std::os::raw::c_char =
+    b"IOPlatformUUID\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+
+// IODTNVRAM property keys
+pub const kIONVRAMDeletePropertyKey: *const ::std::os::raw::c_char =
+    b"IONVRAM-DELETE-PROPERTY\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIONVRAMSyncNowPropertyKey: *const ::std::os::raw::c_char =
+    b"IONVRAM-SYNCNOW-PROPERTY\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+pub const kIONVRAMActivateCSRConfigPropertyKey: *const ::std::os::raw::c_char =
+    b"IONVRAM-ARMCSR-PROPERTY\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIODTNVRAMPanicInfoKey: *const ::std::os::raw::c_char =
+    b"aapl,panic-info\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+
+// keys for complex boot information
+pub const kIOBootDeviceKey: *const ::std::os::raw::c_char =
+    b"IOBootDevice\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOBootDevicePathKey: *const ::std::os::raw::c_char =
+    b"IOBootDevicePath\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOBootDeviceSizeKey: *const ::std::os::raw::c_char =
+    b"IOBootDeviceSize\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+
+// keys for OS Version information
+pub const kOSBuildVersionKey: *const ::std::os::raw::c_char =
+    b"OS Build Version\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;

vendor/io-kit-sys/src/lib.rs

@@ -0,0 +1,572 @@
+#![allow(non_camel_case_types)]
+#![allow(non_upper_case_globals)]
+#![allow(non_snake_case)]
+
+extern crate core_foundation_sys;
+extern crate mach2;
+
+pub mod base;
+pub mod keys;
+pub mod ret;
+pub mod types;
+
+pub mod hid;
+pub mod ps;
+pub mod pwr_mgt;
+pub mod serial;
+pub mod usb;
+
+use std::os::raw::{c_char, c_int, c_void};
+
+use core_foundation_sys::base::{CFAllocatorRef, CFTypeRef};
+use core_foundation_sys::dictionary::{CFDictionaryRef, CFMutableDictionaryRef};
+use core_foundation_sys::runloop::CFRunLoopSourceRef;
+use core_foundation_sys::string::CFStringRef;
+use mach2::boolean::boolean_t;
+use mach2::clock_types::mach_timespec_t;
+use mach2::kern_return::kern_return_t;
+use mach2::mach_types::task_port_t;
+use mach2::message::mach_msg_header_t;
+use mach2::port::mach_port_t;
+use mach2::vm_types::{mach_vm_address_t, mach_vm_size_t};
+
+use base::dispatch_queue_t;
+use ret::IOReturn;
+use types::{
+    io_connect_t, io_iterator_t, io_object_t, io_registry_entry_t, io_service_t, IOOptionBits,
+};
+
+// exports from <CoreFoundation/CFString.h>
+extern "C" {
+    fn __CFStringMakeConstantString(cStr: *const c_char) -> CFStringRef;
+}
+
+pub fn CFSTR(cStr: *const c_char) -> CFStringRef {
+    unsafe { __CFStringMakeConstantString(cStr) }
+}
+
+// exports from <IOKit/IOKitLib.h>
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IONotificationPort {
+    _unused: [u8; 0],
+}
+
+pub type IONotificationPortRef = *mut IONotificationPort;
+
+pub type IOServiceMatchingCallback =
+    unsafe extern "C" fn(refcon: *mut c_void, iterator: io_iterator_t);
+
+pub type IOServiceInterestCallback = unsafe extern "C" fn(
+    refcon: *mut c_void,
+    service: io_service_t,
+    messageType: u32,
+    messageArgument: *mut c_void,
+);
+
+extern "C" {
+    #[link_name = "kIOMasterPortDefault"]
+    pub static kIOMasterPortDefault: mach_port_t;
+
+    pub fn IOMasterPort(bootstrapPort: mach_port_t, masterPort: *mut mach_port_t) -> kern_return_t;
+
+    pub fn IONotificationPortCreate(masterPort: mach_port_t) -> IONotificationPortRef;
+
+    pub fn IONotificationPortDestroy(notify: IONotificationPortRef);
+
+    pub fn IONotificationPortGetRunLoopSource(notify: IONotificationPortRef) -> CFRunLoopSourceRef;
+
+    pub fn IONotificationPortGetMachPort(notify: IONotificationPortRef) -> mach_port_t;
+
+    pub fn IONotificationPortSetDispatchQueue(
+        notify: IONotificationPortRef,
+        queue: dispatch_queue_t,
+    );
+
+    pub fn IODispatchCalloutFromMessage(
+        unused: *mut c_void,
+        msg: *mut mach_msg_header_t,
+        reference: *mut c_void,
+    );
+
+    pub fn IOCreateReceivePort(msgType: u32, recvPort: *mut mach_port_t) -> kern_return_t;
+}
+
+// IOObject
+extern "C" {
+    pub fn IOObjectRelease(object: io_object_t) -> kern_return_t;
+
+    pub fn IOObjectRetain(object: io_object_t) -> kern_return_t;
+
+    pub fn IOObjectGetClass(object: io_object_t, className: *mut c_char) -> kern_return_t;
+
+    pub fn IOObjectCopyClass(object: io_object_t) -> CFStringRef;
+
+    pub fn IOObjectCopySuperclassForClass(classname: CFStringRef) -> CFStringRef;
+
+    pub fn IOObjectCopyBundleIdentifierForClass(classname: CFStringRef) -> CFStringRef;
+
+    pub fn IOObjectConformsTo(object: io_object_t, className: *mut c_char) -> boolean_t;
+
+    pub fn IOObjectIsEqualTo(object: io_object_t, anObject: io_object_t) -> boolean_t;
+
+    pub fn IOObjectGetKernelRetainCount(object: io_object_t) -> u32;
+
+    pub fn IOObjectGetUserRetainCount(object: io_object_t) -> u32;
+
+    pub fn IOObjectGetRetainCount(object: io_object_t) -> u32;
+}
+
+// IOIterator, subclass of IOObject
+extern "C" {
+    pub fn IOIteratorNext(iterator: io_iterator_t) -> io_object_t;
+
+    pub fn IOIteratorReset(iterator: io_iterator_t);
+
+    pub fn IOIteratorIsValid(iterator: io_iterator_t) -> boolean_t;
+}
+
+// IOService, subclass of IORegistryEntry
+extern "C" {
+    pub fn IOServiceGetMatchingService(
+        masterPort: mach_port_t,
+        matching: CFDictionaryRef,
+    ) -> io_service_t;
+
+    pub fn IOServiceGetMatchingServices(
+        masterPort: mach_port_t,
+        matching: CFDictionaryRef,
+        existing: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceAddNotification(
+        masterPort: mach_port_t,
+        notificationType: *mut c_char,
+        matching: CFDictionaryRef,
+        wakePort: mach_port_t,
+        reference: usize,
+        notification: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceAddMatchingNotification(
+        notifyPort: IONotificationPortRef,
+        notificationType: *mut c_char,
+        matching: CFDictionaryRef,
+        callback: IOServiceMatchingCallback,
+        refCon: *mut c_void,
+        notification: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceAddInterestNotification(
+        notifyPort: IONotificationPortRef,
+        service: io_service_t,
+        interestType: *mut c_char,
+        callback: IOServiceInterestCallback,
+        refCon: *mut c_void,
+        notification: *mut io_object_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceMatchPropertyTable(
+        service: io_service_t,
+        matching: CFDictionaryRef,
+        matches: *mut boolean_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceGetBusyState(service: io_service_t, busyState: *mut u32) -> kern_return_t;
+
+    pub fn IOServiceWaitQuiet(
+        service: io_service_t,
+        waitTime: *mut mach_timespec_t,
+    ) -> kern_return_t;
+
+    pub fn IOKitGetBusyState(masterPort: mach_port_t, busyState: *mut u32) -> kern_return_t;
+
+    pub fn IOKitWaitQuiet(masterPort: mach_port_t, waitTime: *mut mach_timespec_t)
+        -> kern_return_t;
+
+    pub fn IOServiceOpen(
+        service: io_service_t,
+        owningTask: task_port_t,
+        type_: u32,
+        connect: *mut io_connect_t,
+    ) -> kern_return_t;
+
+    pub fn IOServiceRequestProbe(service: io_service_t, options: u32) -> kern_return_t;
+}
+
+// options for IOServiceAuthorize()
+pub const kIOServiceInteractionAllowed: u32 = 0x00000001;
+
+extern "C" {
+    pub fn IOServiceAuthorize(service: io_service_t, options: u32) -> kern_return_t;
+
+    pub fn IOServiceOpenAsFileDescriptor(service: io_service_t, oflag: c_int) -> c_int;
+}
+
+// IOService connection
+extern "C" {
+    pub fn IOServiceClose(connect: io_connect_t) -> kern_return_t;
+
+    pub fn IOConnectAddRef(connect: io_connect_t) -> kern_return_t;
+
+    pub fn IOConnectRelease(connect: io_connect_t) -> kern_return_t;
+
+    pub fn IOConnectGetService(connect: io_connect_t, service: *mut io_service_t) -> kern_return_t;
+
+    pub fn IOConnectSetNotificationPort(
+        connect: io_connect_t,
+        type_: u32,
+        port: mach_port_t,
+        reference: usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectMapMemory(
+        connect: io_connect_t,
+        memoryType: u32,
+        intoTask: task_port_t,
+        atAddress: *mut mach_vm_address_t,
+        ofSize: *mut mach_vm_size_t,
+        options: IOOptionBits,
+    ) -> kern_return_t;
+
+    pub fn IOConnectMapMemory64(
+        connect: io_connect_t,
+        memoryType: u32,
+        intoTask: task_port_t,
+        atAddress: *mut mach_vm_address_t,
+        ofSize: *mut mach_vm_size_t,
+        options: IOOptionBits,
+    ) -> kern_return_t;
+
+    pub fn IOConnectUnmapMemory(
+        connect: io_connect_t,
+        memoryType: u32,
+        fromTask: task_port_t,
+        atAddress: mach_vm_address_t,
+    ) -> kern_return_t;
+
+    pub fn IOConnectUnmapMemory64(
+        connect: io_connect_t,
+        memoryType: u32,
+        fromTask: task_port_t,
+        atAddress: mach_vm_address_t,
+    ) -> kern_return_t;
+
+    pub fn IOConnectSetCFProperties(connect: io_connect_t, properties: CFTypeRef) -> kern_return_t;
+
+    pub fn IOConnectSetCFProperty(
+        connect: io_connect_t,
+        propertyName: CFStringRef,
+        property: CFTypeRef,
+    ) -> kern_return_t;
+}
+
+// Combined LP64 & ILP32 Extended IOUserClient::externalMethod
+extern "C" {
+    pub fn IOConnectCallMethod(
+        connection: mach_port_t,
+        selector: u32,
+        input: *const u64,
+        inputCnt: u32,
+        inputStruct: *const c_void,
+        inputStructCnt: usize,
+        output: *mut u64,
+        outputCnt: *mut u32,
+        outputStruct: *mut c_void,
+        outputStructCnt: *mut usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectCallAsyncMethod(
+        connection: mach_port_t,
+        selector: u32,
+        wake_port: mach_port_t,
+        reference: *mut u64,
+        referenceCnt: u32,
+        input: *const u64,
+        inputCnt: u32,
+        inputStruct: *const c_void,
+        inputStructCnt: usize,
+        output: *mut u64,
+        outputCnt: *mut u32,
+        outputStruct: *mut c_void,
+        outputStructCnt: *mut usize,
+    ) -> kern_return_t;
+}
+extern "C" {
+    pub fn IOConnectCallStructMethod(
+        connection: mach_port_t,
+        selector: u32,
+        inputStruct: *const c_void,
+        inputStructCnt: usize,
+        outputStruct: *mut c_void,
+        outputStructCnt: *mut usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectCallAsyncStructMethod(
+        connection: mach_port_t,
+        selector: u32,
+        wake_port: mach_port_t,
+        reference: *mut u64,
+        referenceCnt: u32,
+        inputStruct: *const c_void,
+        inputStructCnt: usize,
+        outputStruct: *mut c_void,
+        outputStructCnt: *mut usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectCallScalarMethod(
+        connection: mach_port_t,
+        selector: u32,
+        input: *const u64,
+        inputCnt: u32,
+        output: *mut u64,
+        outputCnt: *mut u32,
+    ) -> kern_return_t;
+
+    pub fn IOConnectCallAsyncScalarMethod(
+        connection: mach_port_t,
+        selector: u32,
+        wake_port: mach_port_t,
+        reference: *mut u64,
+        referenceCnt: u32,
+        input: *const u64,
+        inputCnt: u32,
+        output: *mut u64,
+        outputCnt: *mut u32,
+    ) -> kern_return_t;
+}
+
+extern "C" {
+    pub fn IOConnectTrap0(connect: io_connect_t, index: u32) -> kern_return_t;
+
+    pub fn IOConnectTrap1(connect: io_connect_t, index: u32, p1: usize) -> kern_return_t;
+
+    pub fn IOConnectTrap2(connect: io_connect_t, index: u32, p1: usize, p2: usize)
+        -> kern_return_t;
+
+    pub fn IOConnectTrap3(
+        connect: io_connect_t,
+        index: u32,
+        p1: usize,
+        p2: usize,
+        p3: usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectTrap4(
+        connect: io_connect_t,
+        index: u32,
+        p1: usize,
+        p2: usize,
+        p3: usize,
+        p4: usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectTrap5(
+        connect: io_connect_t,
+        index: u32,
+        p1: usize,
+        p2: usize,
+        p3: usize,
+        p4: usize,
+        p5: usize,
+    ) -> kern_return_t;
+
+    pub fn IOConnectTrap6(
+        connect: io_connect_t,
+        index: u32,
+        p1: usize,
+        p2: usize,
+        p3: usize,
+        p4: usize,
+        p5: usize,
+        p6: usize,
+    ) -> kern_return_t;
+}
+
+extern "C" {
+    pub fn IOConnectAddClient(connect: io_connect_t, client: io_connect_t) -> kern_return_t;
+
+    pub fn IORegistryGetRootEntry(masterPort: mach_port_t) -> io_registry_entry_t;
+
+    pub fn IORegistryEntryFromPath(
+        masterPort: mach_port_t,
+        path: *mut c_char,
+    ) -> io_registry_entry_t;
+
+    pub fn IORegistryEntryCopyFromPath(
+        masterPort: mach_port_t,
+        path: CFStringRef,
+    ) -> io_registry_entry_t;
+}
+
+pub const kIORegistryIterateRecursively: u32 = 0x00000001;
+pub const kIORegistryIterateParents: u32 = 0x00000002;
+
+extern "C" {
+    pub fn IORegistryCreateIterator(
+        masterPort: mach_port_t,
+        plane: *const c_char,
+        options: IOOptionBits,
+        iterator: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryCreateIterator(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        options: IOOptionBits,
+        iterator: *mut io_iterator_t,
+    ) -> kern_return_t;
+}
+
+// IORegistryIterator, subclass of IOIterator
+extern "C" {
+    pub fn IORegistryIteratorEnterEntry(iterator: io_iterator_t) -> kern_return_t;
+
+    pub fn IORegistryIteratorExitEntry(iterator: io_iterator_t) -> kern_return_t;
+}
+
+// IORegistryEntry, subclass of IOObject
+extern "C" {
+    pub fn IORegistryEntryGetName(entry: io_registry_entry_t, name: *mut c_char) -> kern_return_t;
+
+    pub fn IORegistryEntryGetNameInPlane(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        name: *mut c_char,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetLocationInPlane(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        location: *mut c_char,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetPath(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        path: *mut c_char,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryCopyPath(entry: io_registry_entry_t, plane: *const c_char) -> CFStringRef;
+
+    pub fn IORegistryEntryGetRegistryEntryID(
+        entry: io_registry_entry_t,
+        entryID: *mut u64,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryCreateCFProperties(
+        entry: io_registry_entry_t,
+        properties: *mut CFMutableDictionaryRef,
+        allocator: CFAllocatorRef,
+        options: IOOptionBits,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryCreateCFProperty(
+        entry: io_registry_entry_t,
+        key: CFStringRef,
+        allocator: CFAllocatorRef,
+        options: IOOptionBits,
+    ) -> CFTypeRef;
+
+    pub fn IORegistryEntrySearchCFProperty(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        key: CFStringRef,
+        allocator: CFAllocatorRef,
+        options: IOOptionBits,
+    ) -> CFTypeRef;
+
+    #[deprecated(
+        since = "0.1.0",
+        note = "please use `IORegistryEntryCreateCFProperty` instead"
+    )]
+    pub fn IORegistryEntryGetProperty(
+        entry: io_registry_entry_t,
+        propertyName: *mut c_char,
+        buffer: *mut c_char,
+        size: *mut u32,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntrySetCFProperties(
+        entry: io_registry_entry_t,
+        properties: CFTypeRef,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntrySetCFProperty(
+        entry: io_registry_entry_t,
+        propertyName: CFStringRef,
+        property: CFTypeRef,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetChildIterator(
+        entry: io_registry_entry_t,
+        plane: *mut c_char,
+        iterator: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetChildEntry(
+        entry: io_registry_entry_t,
+        plane: *mut c_char,
+        child: *mut io_registry_entry_t,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetParentIterator(
+        entry: io_registry_entry_t,
+        plane: *mut c_char,
+        iterator: *mut io_iterator_t,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryGetParentEntry(
+        entry: io_registry_entry_t,
+        plane: *const c_char,
+        parent: *mut io_registry_entry_t,
+    ) -> kern_return_t;
+
+    pub fn IORegistryEntryInPlane(entry: io_registry_entry_t, plane: *mut c_char) -> boolean_t;
+}
+
+// Matching dictionary creation helpers
+extern "C" {
+    pub fn IOServiceMatching(name: *const c_char) -> CFMutableDictionaryRef;
+
+    pub fn IOServiceNameMatching(name: *const c_char) -> CFMutableDictionaryRef;
+
+    pub fn IOBSDNameMatching(
+        masterPort: mach_port_t,
+        options: u32,
+        bsdName: *const c_char,
+    ) -> CFMutableDictionaryRef;
+
+    pub fn IOOpenFirmwarePathMatching(
+        masterPort: mach_port_t,
+        options: u32,
+        path: *const c_char,
+    ) -> CFMutableDictionaryRef;
+
+    pub fn IORegistryEntryIDMatching(entryID: u64) -> CFMutableDictionaryRef;
+
+    pub fn IOServiceOFPathToBSDName(
+        masterPort: mach_port_t,
+        openFirmwarePath: *mut c_char,
+        bsdName: *mut c_char,
+    ) -> kern_return_t;
+}
+
+pub type IOAsyncCallback0 = unsafe extern "C" fn(refcon: *mut c_void, result: IOReturn);
+
+pub type IOAsyncCallback1 =
+    unsafe extern "C" fn(refcon: *mut c_void, result: IOReturn, arg0: *mut c_void);
+
+pub type IOAsyncCallback2 = unsafe extern "C" fn(
+    refcon: *mut c_void,
+    result: IOReturn,
+    arg0: *mut c_void,
+    arg1: *mut c_void,
+);
+
+pub type IOAsyncCallback = unsafe extern "C" fn(
+    refcon: *mut c_void,
+    result: IOReturn,
+    args: *mut *mut c_void,
+    numArgs: u32,
+);

vendor/io-kit-sys/src/ps/keys.rs

@@ -0,0 +1,167 @@
+// exports from <IOKit/ps/IOPSKeys.h>
+
+// IOPSPowerAdapter Keys
+pub const kIOPSPowerAdapterIDKey: *const ::std::os::raw::c_char =
+    b"AdapterID\0" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterWattsKey: *const ::std::os::raw::c_char =
+    b"Watts\0" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterRevisionKey: *const ::std::os::raw::c_char =
+    b"AdapterRevision\0" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterSerialNumberKey: *const ::std::os::raw::c_char =
+    b"SerialNumber\0" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterFamilyKey: *const ::std::os::raw::c_char =
+    b"FamilyCode\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterCurrentKey: *const ::std::os::raw::c_char =
+    b"Current\0" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerAdapterSourceKey: *const ::std::os::raw::c_char =
+    b"Source\0" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+
+// Internal Keys
+pub const kIOPSUPSManagementClaimed: *const ::std::os::raw::c_char =
+    b"/IOKit/UPSPowerManagementClaimed\0" as *const [u8; 33usize] as *const ::std::os::raw::c_char;
+pub const kIOPSLowWarnLevelKey: *const ::std::os::raw::c_char =
+    b"Low Warn Level\0" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPSDeadWarnLevelKey: *const ::std::os::raw::c_char =
+    b"Shutdown Level\0" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPSDynamicStorePath: *const ::std::os::raw::c_char =
+    b"/IOKit/PowerSources\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+
+// Power Source Commands (UPS)
+pub const kIOPSCommandDelayedRemovePowerKey: *const ::std::os::raw::c_char =
+    b"Delayed Remove Power\0" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandEnableAudibleAlarmKey: *const ::std::os::raw::c_char =
+    b"Enable Audible Alarm\0" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandStartupDelayKey: *const ::std::os::raw::c_char =
+    b"Startup Delay\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandSetCurrentLimitKey: *const ::std::os::raw::c_char =
+    b"Set Current Limit\0" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandSetRequiredVoltageKey: *const ::std::os::raw::c_char =
+    b"Set Required Voltage\0" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandSendCurrentStateOfCharge: *const ::std::os::raw::c_char =
+    b"Send Current State of Charge\0" as *const [u8; 29usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCommandSendCurrentTemperature: *const ::std::os::raw::c_char =
+    b"Send Current Temperature\0" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+
+// Power Source data keys
+pub const kIOPSPowerSourceIDKey: *const ::std::os::raw::c_char =
+    b"Power Source ID\0" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPowerSourceStateKey: *const ::std::os::raw::c_char =
+    b"Power Source State\0" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCurrentCapacityKey: *const ::std::os::raw::c_char =
+    b"Current Capacity\0" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPSMaxCapacityKey: *const ::std::os::raw::c_char =
+    b"Max Capacity\0" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPSDesignCapacityKey: *const ::std::os::raw::c_char =
+    b"DesignCapacity\0" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPSNominalCapacityKey: *const ::std::os::raw::c_char =
+    b"Nominal Capacity\0" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPSTimeToEmptyKey: *const ::std::os::raw::c_char =
+    b"Time to Empty\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPSTimeToFullChargeKey: *const ::std::os::raw::c_char =
+    b"Time to Full Charge\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSIsChargingKey: *const ::std::os::raw::c_char =
+    b"Is Charging\0" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPSInternalFailureKey: *const ::std::os::raw::c_char =
+    b"Internal Failure\0" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPSIsPresentKey: *const ::std::os::raw::c_char =
+    b"Is Present\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPSVoltageKey: *const ::std::os::raw::c_char =
+    b"Voltage\0" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOPSCurrentKey: *const ::std::os::raw::c_char =
+    b"Current\0" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOPSTemperatureKey: *const ::std::os::raw::c_char =
+    b"Temperature\0" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPSNameKey: *const ::std::os::raw::c_char =
+    b"Name\0" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOPSTypeKey: *const ::std::os::raw::c_char =
+    b"Type\0" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOPSTransportTypeKey: *const ::std::os::raw::c_char =
+    b"Transport Type\0" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPSVendorIDKey: *const ::std::os::raw::c_char =
+    b"Vendor ID\0" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOPSProductIDKey: *const ::std::os::raw::c_char =
+    b"Product ID\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPSVendorDataKey: *const ::std::os::raw::c_char =
+    b"Vendor Specific Data\0" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOPSBatteryHealthKey: *const ::std::os::raw::c_char =
+    b"BatteryHealth\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPSBatteryHealthConditionKey: *const ::std::os::raw::c_char =
+    b"BatteryHealthCondition\0" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOPSBatteryFailureModesKey: *const ::std::os::raw::c_char =
+    b"BatteryFailureModes\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSHealthConfidenceKey: *const ::std::os::raw::c_char =
+    b"HealthConfidence\0" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPSMaxErrKey: *const ::std::os::raw::c_char =
+    b"MaxErr\0" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOPSIsChargedKey: *const ::std::os::raw::c_char =
+    b"Is Charged\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPSIsFinishingChargeKey: *const ::std::os::raw::c_char =
+    b"Is Finishing Charge\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSHardwareSerialNumberKey: *const ::std::os::raw::c_char =
+    b"Hardware Serial Number\0" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+
+// Transport types
+pub const kIOPSSerialTransportType: *const ::std::os::raw::c_char =
+    b"Serial\0" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOPSUSBTransportType: *const ::std::os::raw::c_char =
+    b"USB\0" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOPSNetworkTransportType: *const ::std::os::raw::c_char =
+    b"Ethernet\0" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPSInternalType: *const ::std::os::raw::c_char =
+    b"Internal\0" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+
+// PowerSource Types
+pub const kIOPSInternalBatteryType: *const ::std::os::raw::c_char =
+    b"InternalBattery\0" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPSUPSType: *const ::std::os::raw::c_char =
+    b"UPS\0" as *const [u8; 4usize] as *const ::std::os::raw::c_char;
+pub const kIOPSOffLineValue: *const ::std::os::raw::c_char =
+    b"Off Line\0" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPSACPowerValue: *const ::std::os::raw::c_char =
+    b"AC Power\0" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPSBatteryPowerValue: *const ::std::os::raw::c_char =
+    b"Battery Power\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+
+// Battery Health values
+pub const kIOPSPoorValue: *const ::std::os::raw::c_char =
+    b"Poor\0" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFairValue: *const ::std::os::raw::c_char =
+    b"Fair\0" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOPSGoodValue: *const ::std::os::raw::c_char =
+    b"Good\0" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+
+// Battery Health Condition values
+pub const kIOPSCheckBatteryValue: *const ::std::os::raw::c_char =
+    b"Check Battery\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPSPermanentFailureValue: *const ::std::os::raw::c_char =
+    b"Permanent Battery Failure\0" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+
+// Battery Failure Mode values
+pub const kIOPSFailureExternalInput: *const ::std::os::raw::c_char =
+    b"Externally Indicated Failure\0" as *const [u8; 29usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureSafetyOverVoltage: *const ::std::os::raw::c_char =
+    b"Safety Over-Voltage\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureChargeOverTemp: *const ::std::os::raw::c_char =
+    b"Charge Over-Temperature\0" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureDischargeOverTemp: *const ::std::os::raw::c_char =
+    b"Discharge Over-Temperature\0" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureCellImbalance: *const ::std::os::raw::c_char =
+    b"Cell Imbalance\0" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureChargeFET: *const ::std::os::raw::c_char =
+    b"Charge FET\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureDischargeFET: *const ::std::os::raw::c_char =
+    b"Discharge FET\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureDataFlushFault: *const ::std::os::raw::c_char =
+    b"Data Flush Fault\0" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailurePermanentAFEComms: *const ::std::os::raw::c_char =
+    b"Permanent AFE Comms\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailurePeriodicAFEComms: *const ::std::os::raw::c_char =
+    b"Periodic AFE Comms\0" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureChargeOverCurrent: *const ::std::os::raw::c_char =
+    b"Charge Over-Current\0" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureDischargeOverCurrent: *const ::std::os::raw::c_char =
+    b"Discharge Over-Current\0" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureOpenThermistor: *const ::std::os::raw::c_char =
+    b"Open Thermistor\0" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPSFailureFuseBlown: *const ::std::os::raw::c_char =
+    b"Fuse Blown\0" as *const [u8; 11usize] as *const ::std::os::raw::c_char;

vendor/io-kit-sys/src/ps/mod.rs

@@ -0,0 +1,2 @@
+pub mod keys;
+pub mod power_sources;

vendor/io-kit-sys/src/ps/power_sources.rs

@@ -0,0 +1,56 @@
+// exports from <IOKit/ps/IOPowerSources.h>
+
+use core_foundation_sys::array::CFArrayRef;
+use core_foundation_sys::base::CFTypeRef;
+use core_foundation_sys::dictionary::CFDictionaryRef;
+use core_foundation_sys::runloop::CFRunLoopSourceRef;
+use core_foundation_sys::string::CFStringRef;
+
+// Low Power Warnings
+pub const kIOPSNotifyLowBattery: *const ::std::os::raw::c_char =
+        b"com.apple.system.powersources.lowbattery\0" as *const [u8; 41usize]
+                as *const ::std::os::raw::c_char;
+
+pub type IOPSLowBatteryWarningLevel = u32;
+pub const kIOPSLowBatteryWarningNone: IOPSLowBatteryWarningLevel = 1;
+pub const kIOPSLowBatteryWarningEarly: IOPSLowBatteryWarningLevel = 2;
+pub const kIOPSLowBatteryWarningFinal: IOPSLowBatteryWarningLevel = 3;
+
+pub const kIOPSNotifyTimeRemaining: *const ::std::os::raw::c_char =
+        b"com.apple.system.powersources.timeremaining\0" as *const [u8; 44usize]
+                as *const ::std::os::raw::c_char;
+pub const kIOPSTimeRemainingNotificationKey: *const ::std::os::raw::c_char =
+        kIOPSNotifyTimeRemaining as *const [u8; 44usize] as *const ::std::os::raw::c_char;
+pub const kIOPSNotifyPowerSource: *const ::std::os::raw::c_char =
+        b"com.apple.system.powersources.source\0" as *const [u8; 37usize]
+                as *const ::std::os::raw::c_char;
+pub const kIOPSNotifyAttach: *const ::std::os::raw::c_char =
+        b"com.apple.system.powersources.attach\0" as *const [u8; 37usize]
+                as *const ::std::os::raw::c_char;
+pub const kIOPSNotifyAnyPowerSource: *const ::std::os::raw::c_char =
+        b"com.apple.system.powersources\0" as *const [u8; 30usize] as *const ::std::os::raw::c_char;
+pub const kIOPMUPSPowerKey: *const ::std::os::raw::c_char =
+        b"UPS Power\0" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOPMBatteryPowerKey: *const ::std::os::raw::c_char =
+        b"Battery Power\0" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPMACPowerKey: *const ::std::os::raw::c_char =
+        b"AC Power\0" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+
+pub type IOPowerSourceCallbackType = unsafe extern "C" fn(context: *mut ::std::os::raw::c_void);
+
+extern "C" {
+        pub fn IOPSGetBatteryWarningLevel() -> IOPSLowBatteryWarningLevel;
+        pub fn IOPSCopyPowerSourcesInfo() -> CFTypeRef;
+        pub fn IOPSCopyPowerSourcesList(blob: CFTypeRef) -> CFArrayRef;
+        pub fn IOPSGetPowerSourceDescription(blob: CFTypeRef, ps: CFTypeRef) -> CFDictionaryRef;
+        pub fn IOPSGetProvidingPowerSourceType(snapshot: CFTypeRef) -> CFStringRef;
+        pub fn IOPSNotificationCreateRunLoopSource(
+                callback: IOPowerSourceCallbackType,
+                context: *mut ::std::os::raw::c_void,
+        ) -> CFRunLoopSourceRef;
+        pub fn IOPSCreateLimitedPowerNotification(
+                callback: IOPowerSourceCallbackType,
+                context: *mut ::std::os::raw::c_void,
+        ) -> CFRunLoopSourceRef;
+        pub fn IOPSCopyExternalPowerAdapterDetails() -> CFDictionaryRef;
+}

vendor/io-kit-sys/src/pwr_mgt/mod.rs

@@ -0,0 +1 @@
+pub mod pm;

vendor/io-kit-sys/src/pwr_mgt/pm.rs

@@ -0,0 +1,496 @@
+// exports from <IOKit/pwr_mgt/IOPM.h>
+
+// IOPMMaxPowerStates
+pub const kIOPMMaxPowerStates: u32 = 10;
+pub const IOPMMaxPowerStates: u32 = kIOPMMaxPowerStates;
+
+// IOPMPowerFlags
+pub type IOPMPowerFlags = ::std::os::raw::c_ulong;
+pub const kIOPMPowerOn: u32 = 0x00000002;
+pub const kIOPMDeviceUsable: u32 = 0x00008000;
+pub const kIOPMLowPower: u32 = 0x00010000;
+pub const kIOPMPreventIdleSleep: u32 = 0x00000040;
+pub const kIOPMSleepCapability: u32 = 0x00000004;
+pub const kIOPMRestartCapability: u32 = 0x00000080;
+pub const kIOPMSleep: u32 = 0x00000001;
+pub const kIOPMRestart: u32 = 0x00000080;
+pub const kIOPMInitialDeviceState: u32 = 0x00000100;
+pub const kIOPMRootDomainState: u32 = 0x00000200;
+
+// Private IOPMPowerFlags
+pub const kIOPMClockNormal: u32 = 0x0004;
+pub const kIOPMClockRunning: u32 = 0x0008;
+pub const kIOPMPreventSystemSleep: u32 = 0x0010;
+pub const kIOPMDoze: u32 = 0x0400;
+pub const kIOPMChildClamp: u32 = 0x0080;
+pub const kIOPMChildClamp2: u32 = 0x0200;
+pub const kIOPMNotPowerManaged: u32 = 0x0800;
+
+// Deprecated IOPMPowerFlags
+pub const kIOPMMaxPerformance: u32 = 0x4000;
+pub const kIOPMPassThrough: u32 = 0x0100;
+pub const kIOPMAuxPowerOn: u32 = 0x0020;
+pub const kIOPMNotAttainable: u32 = 0x0001;
+pub const kIOPMContextRetained: u32 = 0x2000;
+pub const kIOPMConfigRetained: u32 = 0x1000;
+pub const kIOPMStaticPowerValid: u32 = 0x0800;
+pub const kIOPMSoftSleep: u32 = 0x0400;
+pub const kIOPMCapabilitiesMask: u32 = kIOPMPowerOn
+    | kIOPMDeviceUsable
+    | kIOPMMaxPerformance
+    | kIOPMContextRetained
+    | kIOPMConfigRetained
+    | kIOPMSleepCapability
+    | kIOPMRestartCapability;
+
+// Support for old names of IOPMPowerFlag constants
+pub const IOPMNotAttainable: u32 = kIOPMNotAttainable;
+pub const IOPMPowerOn: u32 = kIOPMPowerOn;
+pub const IOPMClockNormal: u32 = kIOPMClockNormal;
+pub const IOPMClockRunning: u32 = kIOPMClockRunning;
+pub const IOPMAuxPowerOn: u32 = kIOPMAuxPowerOn;
+pub const IOPMDeviceUsable: u32 = kIOPMDeviceUsable;
+pub const IOPMMaxPerformance: u32 = kIOPMMaxPerformance;
+pub const IOPMContextRetained: u32 = kIOPMContextRetained;
+pub const IOPMConfigRetained: u32 = kIOPMConfigRetained;
+pub const IOPMNotPowerManaged: u32 = kIOPMNotPowerManaged;
+pub const IOPMSoftSleep: u32 = kIOPMSoftSleep;
+
+pub const kIOPMNextHigherState: u32 = 1;
+pub const kIOPMHighestState: u32 = 2;
+pub const kIOPMNextLowerState: u32 = 3;
+pub const kIOPMLowestState: u32 = 4;
+
+pub const IOPMNextHigherState: u32 = kIOPMNextHigherState;
+pub const IOPMHighestState: u32 = kIOPMHighestState;
+pub const IOPMNextLowerState: u32 = kIOPMNextLowerState;
+pub const IOPMLowestState: u32 = kIOPMLowestState;
+
+// Internal commands used by power managment command queue
+pub const kIOPMBroadcastAggressiveness: u32 = 1;
+pub const kIOPMUnidleDevice: u32 = 2;
+
+// Power consumption unknown value
+pub const kIOPMUnknown: u32 = 0xFFFF;
+
+// AppleClamshellState
+pub const kAppleClamshellStateKey: *const ::std::os::raw::c_char =
+    b"AppleClamshellState\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+
+// AppleClamshellCausesSleep
+pub const kAppleClamshellCausesSleepKey: *const ::std::os::raw::c_char =
+    b"AppleClamshellCausesSleep\x00" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+
+// kIOPMSleepWakeUUIDKey
+pub const kIOPMSleepWakeUUIDKey: *const ::std::os::raw::c_char =
+    b"SleepWakeUUID\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+
+// kIOPMBootSessionUUIDKey
+pub const kIOPMBootSessionUUIDKey: *const ::std::os::raw::c_char =
+    b"BootSessionUUID\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+
+// kIOPMDeepSleepEnabledKey
+pub const kIOPMDeepSleepEnabledKey: *const ::std::os::raw::c_char =
+    b"Standby Enabled\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+
+// kIOPMDeepSleepDelayKey
+pub const kIOPMDeepSleepDelayKey: *const ::std::os::raw::c_char =
+    b"Standby Delay\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+
+// kIOPMDeepSleepDelayHighKey
+pub const kIOPMDeepSleepDelayHighKey: *const ::std::os::raw::c_char =
+    b"High Standby Delay\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+
+// kIOPMLowBatteryThresholdKey
+pub const kIOPMStandbyBatteryThresholdKey: *const ::std::os::raw::c_char =
+    b"Standby Battery Threshold\x00" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+
+// kIOPMDestroyFVKeyOnStandbyKey
+pub const kIOPMDestroyFVKeyOnStandbyKey: *const ::std::os::raw::c_char =
+    b"DestroyFVKeyOnStandby\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+
+// kIOPMResetPowerStateOnWakeKey
+pub const kIOPMResetPowerStateOnWakeKey: *const ::std::os::raw::c_char =
+    b"IOPMResetPowerStateOnWake\x00" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+
+// Driver Assertion bitfield description
+pub const kIOPMDriverAssertionCPUBit: u32 = 0x01;
+pub const kIOPMDriverAssertionUSBExternalDeviceBit: u32 = 0x04;
+pub const kIOPMDriverAssertionBluetoothHIDDevicePairedBit: u32 = 0x08;
+pub const kIOPMDriverAssertionExternalMediaMountedBit: u32 = 0x10;
+pub const kIOPMDriverAssertionReservedBit5: u32 = 0x20;
+pub const kIOPMDriverAssertionPreventDisplaySleepBit: u32 = 0x40;
+pub const kIOPMDriverAssertionReservedBit7: u32 = 0x80;
+pub const kIOPMDriverAssertionMagicPacketWakeEnabledBit: u32 = 0x100;
+pub const kIOPMDriverAssertionNetworkKeepAliveActiveBit: u32 = 0x200;
+
+// kIOPMAssertionsDriverKey
+pub const kIOPMAssertionsDriverKey: *const ::std::os::raw::c_char =
+    b"DriverPMAssertions\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPMAssertionsDriverDetailedKey: *const ::std::os::raw::c_char =
+    b"DriverPMAssertionsDetailed\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+
+// Kernel Driver assertion detailed dictionary keys
+pub const kIOPMDriverAssertionIDKey: *const ::std::os::raw::c_char =
+    b"ID\x00" as *const [u8; 3usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionCreatedTimeKey: *const ::std::os::raw::c_char =
+    b"CreatedTime\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionModifiedTimeKey: *const ::std::os::raw::c_char =
+    b"ModifiedTime\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionOwnerStringKey: *const ::std::os::raw::c_char =
+    b"Owner\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionOwnerServiceKey: *const ::std::os::raw::c_char =
+    b"ServicePtr\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionRegistryEntryIDKey: *const ::std::os::raw::c_char =
+    b"RegistryEntryID\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionLevelKey: *const ::std::os::raw::c_char =
+    b"Level\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDriverAssertionAssertedKey: *const ::std::os::raw::c_char =
+    b"Assertions\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+
+// Root Domain general interest messages
+pub const kClamshellStateBit: u32 = 1 << 0;
+pub const kClamshellSleepBit: u32 = 1 << 1;
+pub const kInflowForciblyEnabledBit: u32 = 1 << 0;
+
+// Power commands issued to root domain
+pub const kIOPMSleepNow: u32 = 1 << 0;
+pub const kIOPMAllowSleep: u32 = 1 << 1;
+pub const kIOPMPreventSleep: u32 = 1 << 2;
+pub const kIOPMPowerButton: u32 = 1 << 3;
+pub const kIOPMClamshellClosed: u32 = 1 << 4;
+pub const kIOPMPowerEmergency: u32 = 1 << 5;
+pub const kIOPMDisableClamshell: u32 = 1 << 6;
+pub const kIOPMEnableClamshell: u32 = 1 << 7;
+pub const kIOPMProcessorSpeedChange: u32 = 1 << 8;
+pub const kIOPMOverTemp: u32 = 1 << 9;
+pub const kIOPMClamshellOpened: u32 = 1 << 10;
+pub const kIOPMDWOverTemp: u32 = 1 << 11;
+
+// Power Management Return Codes
+pub const kIOPMNoErr: u32 = 0;
+pub const kIOPMAckImplied: u32 = 0;
+pub const kIOPMWillAckLater: u32 = 1;
+pub const kIOPMBadSpecification: u32 = 4;
+pub const kIOPMNoSuchState: u32 = 5;
+pub const kIOPMCannotRaisePower: u32 = 6;
+pub const kIOPMParameterError: u32 = 7;
+pub const kIOPMNotYetInitialized: u32 = 8;
+// And the old constants; deprecated
+pub const IOPMNoErr: u32 = kIOPMNoErr;
+pub const IOPMAckImplied: u32 = kIOPMAckImplied;
+pub const IOPMWillAckLater: u32 = kIOPMWillAckLater;
+pub const IOPMBadSpecification: u32 = kIOPMBadSpecification;
+pub const IOPMNoSuchState: u32 = kIOPMNoSuchState;
+pub const IOPMCannotRaisePower: u32 = kIOPMCannotRaisePower;
+pub const IOPMParameterError: u32 = kIOPMParameterError;
+pub const IOPMNotYetInitialized: u32 = kIOPMNotYetInitialized;
+
+// IOPMPowerSource class descriptive strings
+pub const kIOPMPSExternalConnectedKey: *const ::std::os::raw::c_char =
+    b"ExternalConnected\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSExternalChargeCapableKey: *const ::std::os::raw::c_char =
+    b"ExternalChargeCapable\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSBatteryInstalledKey: *const ::std::os::raw::c_char =
+    b"BatteryInstalled\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSIsChargingKey: *const ::std::os::raw::c_char =
+    b"IsCharging\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMFullyChargedKey: *const ::std::os::raw::c_char =
+    b"FullyCharged\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAtWarnLevelKey: *const ::std::os::raw::c_char =
+    b"AtWarnLevel\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAtCriticalLevelKey: *const ::std::os::raw::c_char =
+    b"AtCriticalLevel\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSCurrentCapacityKey: *const ::std::os::raw::c_char =
+    b"CurrentCapacity\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSMaxCapacityKey: *const ::std::os::raw::c_char =
+    b"MaxCapacity\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSDesignCapacityKey: *const ::std::os::raw::c_char =
+    b"DesignCapacity\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSTimeRemainingKey: *const ::std::os::raw::c_char =
+    b"TimeRemaining\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAmperageKey: *const ::std::os::raw::c_char =
+    b"Amperage\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSVoltageKey: *const ::std::os::raw::c_char =
+    b"Voltage\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSCycleCountKey: *const ::std::os::raw::c_char =
+    b"CycleCount\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSMaxErrKey: *const ::std::os::raw::c_char =
+    b"MaxErr\x00" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterInfoKey: *const ::std::os::raw::c_char =
+    b"AdapterInfo\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSLocationKey: *const ::std::os::raw::c_char =
+    b"Location\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSErrorConditionKey: *const ::std::os::raw::c_char =
+    b"ErrorCondition\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSManufacturerKey: *const ::std::os::raw::c_char =
+    b"Manufacturer\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSManufactureDateKey: *const ::std::os::raw::c_char =
+    b"ManufactureDate\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSModelKey: *const ::std::os::raw::c_char =
+    b"Model\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSSerialKey: *const ::std::os::raw::c_char =
+    b"Serial\x00" as *const [u8; 7usize] as *const ::std::os::raw::c_char;
+pub const kIOPMDeviceNameKey: *const ::std::os::raw::c_char =
+    b"DeviceName\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSLegacyBatteryInfoKey: *const ::std::os::raw::c_char =
+    b"LegacyBatteryInfo\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSBatteryHealthKey: *const ::std::os::raw::c_char =
+    b"BatteryHealth\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSHealthConfidenceKey: *const ::std::os::raw::c_char =
+    b"HealthConfidence\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSCapacityEstimatedKey: *const ::std::os::raw::c_char =
+    b"CapacityEstimated\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSBatteryChargeStatusKey: *const ::std::os::raw::c_char =
+    b"ChargeStatus\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSBatteryTemperatureKey: *const ::std::os::raw::c_char =
+    b"Temperature\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsKey: *const ::std::os::raw::c_char =
+    b"AdapterDetails\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSChargerConfigurationKey: *const ::std::os::raw::c_char =
+    b"ChargerConfiguration\x00" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+
+// kIOPMPSBatteryChargeStatusKey may have one of the following values
+pub const kIOPMBatteryChargeStatusTooHot: *const ::std::os::raw::c_char =
+    b"HighTemperature\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMBatteryChargeStatusTooCold: *const ::std::os::raw::c_char =
+    b"LowTemperature\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPMBatteryChargeStatusTooHotOrCold: *const ::std::os::raw::c_char =
+    b"HighOrLowTemperature\x00" as *const [u8; 21usize] as *const ::std::os::raw::c_char;
+pub const kIOPMBatteryChargeStatusGradient: *const ::std::os::raw::c_char =
+    b"BatteryTemperatureGradient\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+
+// Definitions for battery location, in case of multiple batteries.
+pub const kIOPMPSLocationLeft: u32 = 1001;
+pub const kIOPMPSLocationRight: u32 = 1002;
+
+// Battery quality health types, specified by BatteryHealth and HealthConfidence
+pub const kIOPMUndefinedValue: u32 = 0;
+pub const kIOPMPoorValue: u32 = 1;
+pub const kIOPMFairValue: u32 = 2;
+pub const kIOPMGoodValue: u32 = 3;
+
+// Keys for kIOPMPSAdapterDetailsKey dictionary
+pub const kIOPMPSAdapterDetailsIDKey: *const ::std::os::raw::c_char =
+    b"AdapterID\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsWattsKey: *const ::std::os::raw::c_char =
+    b"Watts\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsRevisionKey: *const ::std::os::raw::c_char =
+    b"AdapterRevision\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsSerialNumberKey: *const ::std::os::raw::c_char =
+    b"SerialNumber\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsFamilyKey: *const ::std::os::raw::c_char =
+    b"FamilyCode\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsAmperageKey: *const ::std::os::raw::c_char =
+    b"Amperage\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsDescriptionKey: *const ::std::os::raw::c_char =
+    b"Description\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsPMUConfigurationKey: *const ::std::os::raw::c_char =
+    b"PMUConfiguration\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsVoltage: *const ::std::os::raw::c_char =
+    b"AdapterVoltage\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsSourceIDKey: *const ::std::os::raw::c_char =
+    b"SourceID\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsErrorFlagsKey: *const ::std::os::raw::c_char =
+    b"ErrorFlags\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsSharedSourceKey: *const ::std::os::raw::c_char =
+    b"SharedSource\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSAdapterDetailsCloakedKey: *const ::std::os::raw::c_char =
+    b"CloakedSource\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+
+// values for kIOPSPowerAdapterFamilyKey
+pub const kIOPSFamilyCodeDisconnected: i32 = 0;
+pub const kIOPSFamilyCodeUnsupported: i32 = -536870201;
+pub const kIOPSFamilyCodeFirewire: i32 = -536838144;
+pub const kIOPSFamilyCodeUSBHost: i32 = -536854528;
+pub const kIOPSFamilyCodeUSBHostSuspended: i32 = -536854527;
+pub const kIOPSFamilyCodeUSBDevice: i32 = -536854526;
+pub const kIOPSFamilyCodeUSBAdapter: i32 = -536854525;
+pub const kIOPSFamilyCodeUSBChargingPortDedicated: i32 = -536854524;
+pub const kIOPSFamilyCodeUSBChargingPortDownstream: i32 = -536854523;
+pub const kIOPSFamilyCodeUSBChargingPort: i32 = -536854522;
+pub const kIOPSFamilyCodeUSBUnknown: i32 = -536854521;
+pub const kIOPSFamilyCodeUSBCBrick: i32 = -536854520;
+pub const kIOPSFamilyCodeUSBCTypeC: i32 = -536854519;
+pub const kIOPSFamilyCodeUSBCPD: i32 = -536854518;
+pub const kIOPSFamilyCodeAC: i32 = -536723456;
+pub const kIOPSFamilyCodeExternal: i32 = -536723455;
+pub const kIOPSFamilyCodeExternal2: i32 = -536723454;
+pub const kIOPSFamilyCodeExternal3: i32 = -536723453;
+pub const kIOPSFamilyCodeExternal4: i32 = -536723452;
+pub const kIOPSFamilyCodeExternal5: i32 = -536723451;
+
+// values for kIOPMPSAdapterDetailsErrorFlagsKey
+pub const kIOPSAdapterErrorFlagNoErrors: u32 = 0;
+pub const kIOPSAdapterErrorFlagInsufficientAvailablePower: u32 = 2;
+pub const kIOPSAdapterErrorFlagForeignObjectDetected: u32 = 4;
+pub const kIOPSAdapterErrorFlagDeviceNeedsToBeRepositioned: u32 = 8;
+
+pub const kIOPMPSInvalidWakeSecondsKey: *const ::std::os::raw::c_char =
+    b"BatteryInvalidWakeSeconds\x00" as *const [u8; 26usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSPostChargeWaitSecondsKey: *const ::std::os::raw::c_char =
+    b"PostChargeWaitSeconds\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOPMPSPostDishargeWaitSecondsKey: *const ::std::os::raw::c_char =
+    b"PostDischargeWaitSeconds\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;
+
+// CPU Power Management status keys
+pub const kIOPMGraphicsPowerLimitsKey: *const ::std::os::raw::c_char =
+    b"Graphics_Power_Limits\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOPMGraphicsPowerLimitPerformanceKey: *const ::std::os::raw::c_char =
+    b"Graphics_Power_Performance\x00" as *const [u8; 27usize] as *const ::std::os::raw::c_char;
+pub const kIOPMCPUPowerLimitsKey: *const ::std::os::raw::c_char =
+    b"CPU_Power_Limits\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPMCPUPowerLimitProcessorSpeedKey: *const ::std::os::raw::c_char =
+    b"CPU_Speed_Limit\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kIOPMCPUPowerLimitProcessorCountKey: *const ::std::os::raw::c_char =
+    b"CPU_Available_CPUs\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPMCPUPowerLimitSchedulerTimeKey: *const ::std::os::raw::c_char =
+    b"CPU_Scheduler_Limit\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPMThermalLevelWarningKey: *const ::std::os::raw::c_char =
+    b"Thermal_Level_Warning\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+
+// Thermal Warning Level values
+pub const kIOPMThermalLevelNormal: u32 = 0;
+pub const kIOPMThermalLevelDanger: u32 = 5;
+pub const kIOPMThermalLevelCritical: u32 = 10;
+pub const kIOPMThermalLevelWarning: u32 = 100;
+pub const kIOPMThermalLevelTrap: u32 = 110;
+pub const kIOPMThermalLevelUnknown: u32 = 255;
+
+// PM Settings Controller setting types
+pub const kIOPMSettingWakeOnRingKey: *const ::std::os::raw::c_char =
+    b"Wake On Modem Ring\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingRestartOnPowerLossKey: *const ::std::os::raw::c_char =
+    b"Automatic Restart On Power Loss\x00" as *const [u8; 32usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingWakeOnACChangeKey: *const ::std::os::raw::c_char =
+    b"Wake On AC Change\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingSleepOnPowerButtonKey: *const ::std::os::raw::c_char =
+    b"Sleep On Power Button\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingWakeOnClamshellKey: *const ::std::os::raw::c_char =
+    b"Wake On Clamshell Open\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingReduceBrightnessKey: *const ::std::os::raw::c_char =
+    b"ReduceBrightness\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingDisplaySleepUsesDimKey: *const ::std::os::raw::c_char =
+    b"Display Sleep Uses Dim\x00" as *const [u8; 23usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingTimeZoneOffsetKey: *const ::std::os::raw::c_char =
+    b"TimeZoneOffsetSeconds\x00" as *const [u8; 22usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingMobileMotionModuleKey: *const ::std::os::raw::c_char =
+    b"MobileMotionModule\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingGraphicsSwitchKey: *const ::std::os::raw::c_char =
+    b"GPUSwitch\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+
+// Setting controlling drivers can register to receive scheduled wake data
+pub const kIOPMSettingAutoWakeSecondsKey: *const ::std::os::raw::c_char =
+    b"wake\x00" as *const [u8; 5usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingAutoWakeCalendarKey: *const ::std::os::raw::c_char =
+    b"WakeByCalendarDate\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingAutoPowerSecondsKey: *const ::std::os::raw::c_char =
+    b"poweron\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingAutoPowerCalendarKey: *const ::std::os::raw::c_char =
+    b"PowerByCalendarDate\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+
+// Debug seconds auto wake
+pub const kIOPMSettingDebugWakeRelativeKey: *const ::std::os::raw::c_char =
+    b"WakeRelativeToSleep\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kIOPMSettingDebugPowerRelativeKey: *const ::std::os::raw::c_char =
+    b"PowerRelativeToShutdown\x00" as *const [u8; 24usize] as *const ::std::os::raw::c_char;
+
+// Maintenance wake calendar.
+pub const kIOPMSettingMaintenanceWakeCalendarKey: *const ::std::os::raw::c_char =
+    b"MaintenanceWakeCalendarDate\x00" as *const [u8; 28usize] as *const ::std::os::raw::c_char;
+
+// SetAggressiveness types
+pub const kPMGeneralAggressiveness: u32 = 0;
+pub const kPMMinutesToDim: u32 = 1;
+pub const kPMMinutesToSpinDown: u32 = 2;
+pub const kPMMinutesToSleep: u32 = 3;
+pub const kPMEthernetWakeOnLANSettings: u32 = 4;
+pub const kPMSetProcessorSpeed: u32 = 5;
+pub const kPMPowerSource: u32 = 6;
+pub const kPMMotionSensor: u32 = 7;
+pub const kPMLastAggressivenessType: u32 = 8;
+
+// SetAggressiveness values for the kPMPowerSource aggressiveness type
+pub const kIOPMInternalPower: u32 = 1;
+pub const kIOPMExternalPower: u32 = 2;
+
+pub const kIOREMSleepEnabledKey: *const ::std::os::raw::c_char =
+    b"REMSleepEnabled\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+
+// Strings for deciphering the dictionary returned from IOPMCopyBatteryInfo
+pub const kIOBatteryInfoKey: *const ::std::os::raw::c_char =
+    b"IOBatteryInfo\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryCurrentChargeKey: *const ::std::os::raw::c_char =
+    b"Current\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryCapacityKey: *const ::std::os::raw::c_char =
+    b"Capacity\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryFlagsKey: *const ::std::os::raw::c_char =
+    b"Flags\x00" as *const [u8; 6usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryVoltageKey: *const ::std::os::raw::c_char =
+    b"Voltage\x00" as *const [u8; 8usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryAmperageKey: *const ::std::os::raw::c_char =
+    b"Amperage\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kIOBatteryCycleCountKey: *const ::std::os::raw::c_char =
+    b"Cycle Count\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+
+pub const kIOBatteryInstalled: u32 = 1 << 2;
+pub const kIOBatteryCharge: u32 = 1 << 1;
+pub const kIOBatteryChargerConnect: u32 = 1 << 0;
+
+pub const IOPM_POWER_SOURCE_REV: u32 = 2;
+
+// For use with IOPMPowerSource bFlags
+pub const kIOPMACInstalled: u32 = kIOBatteryChargerConnect;
+pub const kIOPMBatteryCharging: u32 = kIOBatteryCharge;
+pub const kIOPMBatteryInstalled: u32 = kIOBatteryInstalled;
+pub const kIOPMUPSInstalled: u32 = 1 << 3;
+pub const kIOPMBatteryAtWarn: u32 = 1 << 4;
+pub const kIOPMBatteryDepleted: u32 = 1 << 5;
+pub const kIOPMACnoChargeCapability: u32 = 1 << 6;
+pub const kIOPMRawLowBattery: u32 = 1 << 7;
+pub const kIOPMForceLowSpeed: u32 = 1 << 8;
+pub const kIOPMClosedClamshell: u32 = 1 << 9;
+pub const kIOPMClamshellStateOnWake: u32 = 1 << 10;
+
+// IOPMSystemCapabilityChangeFlags
+pub const kIOPMSystemCapabilityWillChange: u32 = 0x01;
+pub const kIOPMSystemCapabilityDidChange: u32 = 0x02;
+
+pub const kIOPMSystemCapabilityCPU: u32 = 0x01;
+pub const kIOPMSystemCapabilityGraphics: u32 = 0x02;
+pub const kIOPMSystemCapabilityAudio: u32 = 0x04;
+pub const kIOPMSystemCapabilityNetwork: u32 = 0x08;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IOPMCalendarStruct {
+    pub year: ::std::os::raw::c_uint,
+    pub month: ::std::os::raw::c_uchar,
+    pub day: ::std::os::raw::c_uchar,
+    pub hour: ::std::os::raw::c_uchar,
+    pub minute: ::std::os::raw::c_uchar,
+    pub second: ::std::os::raw::c_uchar,
+    pub selector: ::std::os::raw::c_uchar,
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IOPowerStateChangeNotification {
+    pub powerRef: *mut ::std::os::raw::c_void,
+    pub returnValue: ::std::os::raw::c_ulong,
+    pub stateNumber: ::std::os::raw::c_ulong,
+    pub stateFlags: IOPMPowerFlags,
+}
+pub type sleepWakeNote = IOPowerStateChangeNotification;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IOPMSystemCapabilityChangeParameters {
+    pub notifyRef: u32,
+    pub maxWaitForReply: u32,
+    pub changeFlags: u32,
+    pub __reserved1: u32,
+    pub fromCapabilities: u32,
+    pub toCapabilities: u32,
+    pub __reserved2: [u32; 4usize],
+}

vendor/io-kit-sys/src/ret.rs

@@ -0,0 +1,122 @@
+// exports from <IOKit/IOReturn.h>
+
+use std::os::raw::c_int;
+
+use mach2::kern_return::{kern_return_t, KERN_SUCCESS};
+
+// sys_iokit
+const SYS_IOKIT: c_int = ((0x38) & 0x3f) << 26;
+const SUB_IOKIT_COMMON: c_int = ((0) & 0xfff) << 14;
+
+// IOReturn
+pub type IOReturn = kern_return_t;
+// OK
+pub const kIOReturnSuccess: IOReturn = KERN_SUCCESS as c_int;
+// general error
+pub const kIOReturnError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2bc;
+// can't allocate memory
+pub const kIOReturnNoMemory: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2bd;
+// resource shortage
+pub const kIOReturnNoResources: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2be;
+// error during IPC
+pub const kIOReturnIPCError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2bf;
+// no such device
+pub const kIOReturnNoDevice: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c0;
+// privilege violation
+pub const kIOReturnNotPrivileged: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c1;
+// invalid argument
+pub const kIOReturnBadArgument: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c2;
+// device read locked
+pub const kIOReturnLockedRead: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c3;
+// device write locked
+pub const kIOReturnLockedWrite: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c4;
+// exclusive access and device already open
+pub const kIOReturnExclusiveAccess: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c5;
+// sent/received messages had different msg_id
+pub const kIOReturnBadMessageID: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c6;
+// unsupported function
+pub const kIOReturnUnsupported: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c7;
+// misc. VM failure
+pub const kIOReturnVMError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c8;
+// internal error
+pub const kIOReturnInternalError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2c9;
+// General I/O error
+pub const kIOReturnIOError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ca;
+// ???
+// pub const kIOReturn???Error: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2cb;
+// can't acquire lock
+pub const kIOReturnCannotLock: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2cc;
+// device not open
+pub const kIOReturnNotOpen: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2cd;
+// read not supported
+pub const kIOReturnNotReadable: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ce;
+// write not supported
+pub const kIOReturnNotWritable: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2cf;
+// alignment error
+pub const kIOReturnNotAligned: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d0;
+// Media Error
+pub const kIOReturnBadMedia: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d1;
+// device(s) still open
+pub const kIOReturnStillOpen: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d2;
+// rld failure
+pub const kIOReturnRLDError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d3;
+// DMA failure
+pub const kIOReturnDMAError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d4;
+// Device Busy
+pub const kIOReturnBusy: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d5;
+// I/O Timeout
+pub const kIOReturnTimeout: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d6;
+// device offline
+pub const kIOReturnOffline: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d7;
+// not ready
+pub const kIOReturnNotReady: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d8;
+// device not attached
+pub const kIOReturnNotAttached: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2d9;
+// no DMA channels left
+pub const kIOReturnNoChannels: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2da;
+// no space for data
+pub const kIOReturnNoSpace: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2db;
+// ???
+// pub const kIOReturn???Error: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2dc;
+// port already exists
+pub const kIOReturnPortExists: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2dd;
+// can't wire down physical memory
+pub const kIOReturnCannotWire: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2de;
+// no interrupt attached
+pub const kIOReturnNoInterrupt: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2df;
+// no DMA frames enqueued
+pub const kIOReturnNoFrames: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e0;
+// oversized msg received on interrupt port
+pub const kIOReturnMessageTooLarge: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e1;
+// not permitted
+pub const kIOReturnNotPermitted: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e2;
+// no power to device
+pub const kIOReturnNoPower: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e3;
+// media not present
+pub const kIOReturnNoMedia: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e4;
+// media not formatted
+pub const kIOReturnUnformattedMedia: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e5;
+// no such mode
+pub const kIOReturnUnsupportedMode: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e6;
+// data underrun
+pub const kIOReturnUnderrun: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e7;
+// data overrun
+pub const kIOReturnOverrun: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e8;
+// the device is not working properly!
+pub const kIOReturnDeviceError: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2e9;
+// a completion routine is required
+pub const kIOReturnNoCompletion: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ea;
+// operation aborted
+pub const kIOReturnAborted: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2eb;
+// bus bandwidth would be exceeded
+pub const kIOReturnNoBandwidth: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ec;
+// device not responding
+pub const kIOReturnNotResponding: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ed;
+// isochronous I/O request for distant past!
+pub const kIOReturnIsoTooOld: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ee;
+// isochronous I/O request for distant future
+pub const kIOReturnIsoTooNew: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2ef;
+// data was not found
+pub const kIOReturnNotFound: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x2f0;
+// should never be seen
+pub const kIOReturnInvalid: IOReturn = SYS_IOKIT | SUB_IOKIT_COMMON | 0x1;

vendor/io-kit-sys/src/serial/keys.rs

@@ -0,0 +1,26 @@
+// exports from <IOKit/serial/IOSerialKeys.h>
+
+use ::std::os::raw::c_char;
+
+pub const kIOSerialBSDServiceValue: *const c_char =
+    b"IOSerialBSDClient\0" as *const [u8; 18] as *const c_char;
+pub const kIOSerialBSDTypeKey: *const c_char =
+    b"IOSerialBSDClientType\0" as *const [u8; 22] as *const c_char;
+pub const kIOSerialBSDAllTypes: *const c_char =
+    b"IOSerialStream\0" as *const [u8; 15] as *const c_char;
+pub const kIOSerialBSDModemType: *const c_char =
+    b"IOSerialStream\0" as *const [u8; 15] as *const c_char;
+pub const kIOSerialBSDRS232Type: *const c_char =
+    b"IOSerialStream\0" as *const [u8; 15] as *const c_char;
+pub const kIOTTYDeviceKey: *const c_char =
+    b"IOTTYDevice\0" as *const [u8; 12] as *const c_char;
+pub const kIOTTYBaseNameKey: *const c_char =
+    b"IOTTYBaseName\0" as *const [u8; 14] as *const c_char;
+pub const kIOTTYSuffixKey: *const c_char =
+    b"IOTTYSuffix\0" as *const [u8; 12] as *const c_char;
+pub const kIOCalloutDeviceKey: *const c_char =
+    b"IOCalloutDevice\0" as *const [u8; 16] as *const c_char;
+pub const kIODialinDeviceKey: *const c_char =
+    b"IODialinDevice\0" as *const [u8; 15] as *const c_char;
+pub const kIOTTYWaitForIdleKey: *const c_char =
+    b"IOTTYWaitForIdle\0" as *const [u8; 17] as *const c_char;

vendor/io-kit-sys/src/serial/mod.rs

@@ -0,0 +1 @@
+pub mod keys;

vendor/io-kit-sys/src/types.rs

@@ -0,0 +1,172 @@
+// exports from <IOKit/IOTypes.h>
+
+use std::os::raw::{c_char, c_int, c_uint, c_ulonglong};
+
+use mach2::port::mach_port_t;
+use mach2::vm_types::mach_vm_address_t;
+
+pub type IOOptionBits = c_uint;
+pub type IOFixed = c_int;
+pub type IOVersion = c_uint;
+pub type IOItemCount = c_uint;
+pub type IOCacheMode = c_uint;
+
+pub type IOByteCount32 = c_uint;
+pub type IOByteCount64 = c_ulonglong;
+
+pub type IOPhysicalAddress32 = c_uint;
+pub type IOPhysicalAddress64 = c_ulonglong;
+pub type IOPhysicalLength32 = c_uint;
+pub type IOPhysicalLength64 = c_ulonglong;
+
+#[cfg(all(not(target_arch = "arm"), not(target_arch = "x86")))]
+pub type IOVirtualAddress = mach_vm_address_t;
+#[cfg(any(target_arch = "arm", target_arch = "x86"))]
+pub type IOVirtualAddress = vm_address_t;
+
+#[cfg(all(
+    not(target_arch = "arm"),
+    not(target_arch = "x86"),
+    not(target_arch = "x86_64")
+))]
+pub type IOByteCount = IOByteCount64;
+#[cfg(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
+pub type IOByteCount = IOByteCount32;
+
+pub type IOLogicalAddress = IOVirtualAddress;
+
+#[cfg(all(
+    not(target_arch = "arm"),
+    not(target_arch = "x86"),
+    not(target_arch = "x86_64")
+))]
+pub type IOPhysicalAddress = IOPhysicalAddress64;
+#[cfg(all(
+    not(target_arch = "arm"),
+    not(target_arch = "x86"),
+    not(target_arch = "x86_64")
+))]
+pub type IOPhysicalLength = IOPhysicalLength64;
+#[cfg(all(
+    not(target_arch = "arm"),
+    not(target_arch = "x86"),
+    not(target_arch = "x86_64")
+))]
+pub const IOPhysSize: c_int = 64;
+
+#[cfg(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
+pub type IOPhysicalAddress = IOPhysicalAddress32;
+#[cfg(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
+pub type IOPhysicalLength = IOPhysicalAddress32;
+#[cfg(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
+pub const IOPhysSize: c_int = 32;
+
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct IOPhysicalRange {
+    address: IOPhysicalAddress,
+    length: IOByteCount,
+}
+impl Clone for IOPhysicalRange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct IOVirtualRange {
+    address: IOVirtualAddress,
+    length: IOByteCount,
+}
+impl Clone for IOVirtualRange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+#[cfg(all(not(target_arch = "arm"), not(target_arch = "x86")))]
+pub type IOAddressRange = IOVirtualRange;
+#[cfg(any(target_arch = "arm", target_arch = "x86"))]
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct IOAddressRange {
+    address: mach_vm_address_t,
+    length: mach_vm_size_t,
+}
+#[cfg(any(target_arch = "arm", target_arch = "x86"))]
+impl Clone for IOAddressRange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+// Map between #defined or enum'd constants and text description.
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct IONamedValue {
+    value: c_int,
+    name: *const c_char,
+}
+impl Clone for IONamedValue {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+// Memory alignment -- specified as a power of two.
+pub type IOAlignment = c_uint;
+
+pub type io_object_t = mach_port_t;
+
+pub type io_connect_t = io_object_t;
+pub type io_enumerator_t = io_object_t;
+pub type io_iterator_t = io_object_t;
+pub type io_registry_entry_t = io_object_t;
+pub type io_service_t = io_object_t;
+
+pub const IO_OBJECT_NULL: io_object_t = 0;
+
+// IOConnectMapMemory memoryTypes
+pub const kIODefaultMemoryType: c_int = 0;
+
+pub const kIODefaultCache: c_int = 0;
+pub const kIOInhibitCache: c_int = 1;
+pub const kIOWriteThruCache: c_int = 2;
+pub const kIOCopybackCache: c_int = 3;
+pub const kIOWriteCombineCache: c_int = 4;
+pub const kIOCopybackInnerCache: c_int = 5;
+
+// IOMemory mapping options
+pub const kIOMapAnywhere: c_int = 0x00000001;
+
+pub const kIOMapCacheMask: c_int = 0x00000700;
+pub const kIOMapCacheShift: c_int = 8;
+pub const kIOMapDefaultCache: c_int = kIODefaultCache << kIOMapCacheShift;
+pub const kIOMapInhibitCache: c_int = kIOInhibitCache << kIOMapCacheShift;
+pub const kIOMapWriteThruCache: c_int = kIOWriteThruCache << kIOMapCacheShift;
+pub const kIOMapCopybackCache: c_int = kIOCopybackCache << kIOMapCacheShift;
+pub const kIOMapWriteCombineCache: c_int = kIOWriteCombineCache << kIOMapCacheShift;
+pub const kIOMapCopybackInnerCache: c_int = kIOCopybackInnerCache << kIOMapCacheShift;
+
+pub const kIOMapUserOptionsMask: c_int = 0x00000fff;
+
+pub const kIOMapReadOnly: c_int = 0x00001000;
+
+pub const kIOMapStatic: c_int = 0x01000000;
+pub const kIOMapReference: c_int = 0x02000000;
+pub const kIOMapUnique: c_int = 0x04000000;
+pub const kIOMapPrefault: c_int = 0x10000000;
+pub const kIOMapOverwrite: c_int = 0x20000000;
+
+// Scale Factors
+pub const kNanosecondScale: c_int = 1;
+pub const kMicrosecondScale: c_int = 1000;
+pub const kMillisecondScale: c_int = 1000 * 1000;
+pub const kSecondScale: c_int = 1000 * 1000 * 1000;
+pub const kTickScale: c_int = kSecondScale / 100;
+
+pub const kIOConnectMethodVarOutputSize: c_int = -3;
+
+// compatibility types
+pub type IODeviceNumber = c_uint;

vendor/io-kit-sys/src/usb/lib.rs

@@ -0,0 +1,5 @@
+// exports from <IOKit/usb/IOUSBLib.h>
+pub const kIOUSBDeviceClassName: *const ::std::os::raw::c_char =
+    b"IOUSBDevice\x00" as *const [u8; 12usize] as *const ::std::os::raw::c_char;
+pub const kIOUSBInterfaceClassName: *const ::std::os::raw::c_char =
+    b"kIOUSBInterfaceClassName\x00" as *const [u8; 25usize] as *const ::std::os::raw::c_char;

vendor/io-kit-sys/src/usb/mod.rs

@@ -0,0 +1,2 @@
+pub mod lib;
+pub mod usb_spec;

vendor/io-kit-sys/src/usb/usb_spec.rs

@@ -0,0 +1,50 @@
+// exports from <IOKit/usb/USBSpec.h>
+
+pub const kUSBDeviceClass: *const ::std::os::raw::c_char =
+    b"bDeviceClass\x00" as *const [u8; 13usize] as *const ::std::os::raw::c_char;
+pub const kUSBDeviceSubClass: *const ::std::os::raw::c_char =
+    b"bDeviceSubClass\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kUSBDeviceProtocol: *const ::std::os::raw::c_char =
+    b"bDeviceProtocol\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kUSBDeviceMaxPacketSize: *const ::std::os::raw::c_char =
+    b"bMaxPacketSize0\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kUSBVendorID: *const ::std::os::raw::c_char =
+    b"idVendor\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kUSBVendorName: *const ::std::os::raw::c_char = kUSBVendorID;
+pub const kUSBProductID: *const ::std::os::raw::c_char =
+    b"idProduct\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kUSBProductName: *const ::std::os::raw::c_char = kUSBProductID;
+pub const kUSBDeviceReleaseNumber: *const ::std::os::raw::c_char =
+    b"bcdDevice\x00" as *const [u8; 10usize] as *const ::std::os::raw::c_char;
+pub const kUSBManufacturerStringIndex: *const ::std::os::raw::c_char =
+    b"iManufacturer\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kUSBProductStringIndex: *const ::std::os::raw::c_char =
+    b"iProduct\x00" as *const [u8; 9usize] as *const ::std::os::raw::c_char;
+pub const kUSBSerialNumberStringIndex: *const ::std::os::raw::c_char =
+    b"iSerialNumber\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kUSBDeviceNumConfigs: *const ::std::os::raw::c_char =
+    b"bNumConfigurations\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kUSBInterfaceNumber: *const ::std::os::raw::c_char =
+    b"bInterfaceNumber\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kUSBAlternateSetting: *const ::std::os::raw::c_char =
+    b"bAlternateSetting\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kUSBNumEndpoints: *const ::std::os::raw::c_char =
+    b"bNumEndpoints\x00" as *const [u8; 14usize] as *const ::std::os::raw::c_char;
+pub const kUSBInterfaceClass: *const ::std::os::raw::c_char =
+    b"bInterfaceClass\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kUSBInterfaceSubClass: *const ::std::os::raw::c_char =
+    b"bInterfaceSubClass\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kUSBInterfaceProtocol: *const ::std::os::raw::c_char =
+    b"bInterfaceProtocol\x00" as *const [u8; 19usize] as *const ::std::os::raw::c_char;
+pub const kUSBInterfaceStringIndex: *const ::std::os::raw::c_char =
+    b"iInterface\x00" as *const [u8; 11usize] as *const ::std::os::raw::c_char;
+pub const kUSBConfigurationValue: *const ::std::os::raw::c_char =
+    b"bConfigurationValue\x00" as *const [u8; 20usize] as *const ::std::os::raw::c_char;
+pub const kUSBProductString: *const ::std::os::raw::c_char =
+    b"USB Product Name\x00" as *const [u8; 17usize] as *const ::std::os::raw::c_char;
+pub const kUSBVendorString: *const ::std::os::raw::c_char =
+    b"USB Vendor Name\x00" as *const [u8; 16usize] as *const ::std::os::raw::c_char;
+pub const kUSBSerialNumberString: *const ::std::os::raw::c_char =
+    b"USB Serial Number\x00" as *const [u8; 18usize] as *const ::std::os::raw::c_char;
+pub const kUSB1284DeviceID: *const ::std::os::raw::c_char =
+    b"1284 Device ID\x00" as *const [u8; 15usize] as *const ::std::os::raw::c_char;