robert/another-boids-in-rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Vendor dependencies for 0.3.0 release

Browse Source
This commit is contained in:
Robert Garrett
2025-09-27 10:29:08 -05:00
parent 0c8d39d483
commit 82ab7f317b
26803 changed files with 16134934 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
vendor/io-kit-sys/.cargo-checksum.json vendored Normal file
View File

@@ -0,0 +1 @@
{"files":{"Cargo.toml":"1afc1628ba068953da176a36eb2502976499377e2f3419d98b4981b5e51f41b4","LICENSE-APACHE":"7f45563da8518d28291f2931f3ec78dfd238a4e2612eb7351933e72b7a68203a","LICENSE-MIT":"52291085f8530d441f958295a04cba4ecdb2aa734c0731a5f2dd58105eb3fe10","build.rs":"c8619135a3c7096af06bb694d551682a3ab93286555812f432d7dd68cd9cd599","src/base.rs":"447653a6eb2bb06e4f8cc3e90071d4809d7fe0d355670d4e6489ca3f759d8be7","src/hid/base.rs":"20dfd8f7dea216de5f41e51cc6c60e15a9fb993ec42dbae1024c8a2a07d11dc0","src/hid/device.rs":"b13fb42b756d8a61b7eb2bb159ace27640a886cc0bff312cefe956e082ba9359","src/hid/element.rs":"ba0d82645884d631d345c2d35c745b8966b55dda6280106f429cfc0f2b551fd1","src/hid/keys.rs":"804b579f3477ec2c5529fbe57ae508bf53d2c1a48534cb28fbefa0654e286e1c","src/hid/manager.rs":"bf5e8a57e7a202e82a38a2a7ee7719c26a32ed5974dfecd04fbee27a4118ab64","src/hid/mod.rs":"93950f983777a09e9b6824611dae20e04f181ab1f775263dea5b79f70321340f","src/hid/usage_tables.rs":"3bead17378820a9e885b6f29244b08ec13a25b61177f8955409b2be048d555e0","src/hid/value.rs":"851d295c5ab103d15f4eea12f799cec35dfcb3de70bf53b15138ad9fc65c5c7b","src/keys.rs":"545371016a89d726ab2dffb692ca4c9c64e550ff9c78dc4713227f191d52a0cb","src/lib.rs":"49a136f1713665531288afc97a4c512f41dbfea7a6fb7bf5c7725cd70ade7de3","src/ps/keys.rs":"a07e6b0a0b83d36d60f08ef8149e9eef72fe547f224b068b1f49f602107db312","src/ps/mod.rs":"42a42935bd294802c16c71b21f9781b3ca4a59f5f0a71d14dbc742d6a666b671","src/ps/power_sources.rs":"2a32e8cca6e792200e1af4404bcf0cdb58ed6e35c3d59d1e3f2ad7ad8d89395a","src/pwr_mgt/mod.rs":"671bd3588ce540f3ecf07280d013e44b44dec3132221c91e88e2abce4c28f338","src/pwr_mgt/pm.rs":"e6643434ba76ae75a306e7d837cbbd4d73c576522a1cc0515dd14844f9b4aa7a","src/ret.rs":"8ad1c488f965891d187708d3505cc1b1310c9b51f591128c6f99065eabccf6b2","src/serial/keys.rs":"32886d2e99b536626d1eef34484df8ed6b687d26883af476259dd3dc2ada5b13","src/serial/mod.rs":"e0ff631fe2d715bfca85bdd09e4d29ab3be651e89b5d07163a5045558f6f44cf","src/types.rs":"91327cae5cf16a5c52e93b519801bba3ed86c069288a3cdf405b269df2539eea","src/usb/lib.rs":"7ad9b9988898e4876759b1f543ca4f467c95d307125be4f5e5b7486d6af23957","src/usb/mod.rs":"71ec2cc841bafdebba98b2ca7016e3712c160411e4d7e37897f92da4c242e7c0","src/usb/usb_spec.rs":"c898b403c0721372ea77ba07bd1752413b12ad8cfc1a887795b6b1132aaa69ba"},"package":"617ee6cf8e3f66f3b4ea67a4058564628cde41901316e19f559e14c7c72c5e7b"}

27
vendor/io-kit-sys/Cargo.toml vendored Normal file
View File

@@ -0,0 +1,27 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
edition = "2021"
name = "io-kit-sys"
version = "0.4.1"
authors = ["Junji Takakura <j.takakura@gmail.com>"]
build = "build.rs"
description = "Bindings to IOKit for macOS"
homepage = "https://github.com/jtakakura/io-kit-rs"
license = "MIT / Apache-2.0"
repository = "https://github.com/jtakakura/io-kit-rs"
[dependencies.core-foundation-sys]
version = "0.8.6"
[dependencies.mach2]
version = "0.4.2"

203
vendor/io-kit-sys/LICENSE-APACHE vendored Normal file
View File

@@ -0,0 +1,203 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright (c) 2017-2018 Junji Takakura
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

7
vendor/io-kit-sys/LICENSE-MIT vendored Normal file
View File

@@ -0,0 +1,7 @@
Copyright (c) 2017-2018 Junji Takakura
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

5
vendor/io-kit-sys/build.rs vendored Normal file
View File

@@ -0,0 +1,5 @@
fn main() {
if std::env::var("TARGET").unwrap().contains("-apple") {
println!("cargo:rustc-link-lib=framework=IOKit");
}
}

17
vendor/io-kit-sys/src/base.rs vendored Normal file
View File

@@ -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;

78
vendor/io-kit-sys/src/hid/base.rs vendored Normal file
View File

@@ -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,
);

192
vendor/io-kit-sys/src/hid/device.rs vendored Normal file
View File

@@ -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;
}

87
vendor/io-kit-sys/src/hid/element.rs vendored Normal file
View File

@@ -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;
}

250
vendor/io-kit-sys/src/hid/keys.rs vendored Normal file
View File

@@ -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;

108
vendor/io-kit-sys/src/hid/manager.rs vendored Normal file
View File

@@ -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,
);
}

7
vendor/io-kit-sys/src/hid/mod.rs vendored Normal file
View File

@@ -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;

1908
vendor/io-kit-sys/src/hid/usage_tables.rs vendored Normal file
View File

File diff suppressed because it is too large Load Diff

47
vendor/io-kit-sys/src/hid/value.rs vendored Normal file
View File

@@ -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;
}

192
vendor/io-kit-sys/src/keys.rs vendored Normal file
View File

@@ -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;

572
vendor/io-kit-sys/src/lib.rs vendored Normal file
View File

@@ -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,
);

167
vendor/io-kit-sys/src/ps/keys.rs vendored Normal file
View File

@@ -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;

2
vendor/io-kit-sys/src/ps/mod.rs vendored Normal file
View File

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

56
vendor/io-kit-sys/src/ps/power_sources.rs vendored Normal file
View File

@@ -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;
}

1
vendor/io-kit-sys/src/pwr_mgt/mod.rs vendored Normal file
View File

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

496
vendor/io-kit-sys/src/pwr_mgt/pm.rs vendored Executable file
View File

@@ -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],
}

122
vendor/io-kit-sys/src/ret.rs vendored Normal file
View File

@@ -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;

26
vendor/io-kit-sys/src/serial/keys.rs vendored Normal file
View File

@@ -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;

1
vendor/io-kit-sys/src/serial/mod.rs vendored Normal file
View File

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

172
vendor/io-kit-sys/src/types.rs vendored Normal file
View File

@@ -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;

5
vendor/io-kit-sys/src/usb/lib.rs vendored Normal file
View File

@@ -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;

2
vendor/io-kit-sys/src/usb/mod.rs vendored Normal file
View File

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

50
vendor/io-kit-sys/src/usb/usb_spec.rs vendored Normal file
View File

@@ -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;