1use core::ffi::*;
4use core::ptr::NonNull;
5#[cfg(feature = "objc2")]
6use objc2::__framework_prelude::*;
7
8use crate::*;
9
10pub const kCallInterfaceOpenWithGate: &CStr =
12 unsafe { CStr::from_bytes_with_nul_unchecked(b"kCallInterfaceOpenWithGate\0") };
13pub const kIOUSBUnknownPipeErr: c_uint = iokit_usb_err!(0x61);
15pub const kIOUSBTooManyPipesErr: c_uint = iokit_usb_err!(0x60);
17pub const kIOUSBNoAsyncPortErr: c_uint = iokit_usb_err!(0x5f);
19pub const kIOUSBNotEnoughPipesErr: c_uint = iokit_usb_err!(0x5e);
21pub const kIOUSBNotEnoughPowerErr: c_uint = iokit_usb_err!(0x5d);
23pub const kIOUSBEndpointNotFound: c_uint = iokit_usb_err!(0x57);
25pub const kIOUSBConfigNotFound: c_uint = iokit_usb_err!(0x56);
27pub const kIOUSBPortWasSuspended: c_uint = iokit_usb_err!(0x52);
29pub const kIOUSBPipeStalled: c_uint = iokit_usb_err!(0x4f);
31pub const kIOUSBInterfaceNotFound: c_uint = iokit_usb_err!(0x4e);
33pub const kIOUSBLowLatencyBufferNotPreviouslyAllocated: c_uint = iokit_usb_err!(0x4d);
35pub const kIOUSBLowLatencyFrameListNotPreviouslyAllocated: c_uint = iokit_usb_err!(0x4c);
37pub const kIOUSBHighSpeedSplitError: c_uint = iokit_usb_err!(0x4b);
39pub const kIOUSBSyncRequestOnWLThread: c_uint = iokit_usb_err!(0x4a);
41pub const kIOUSBDeviceNotHighSpeed: c_uint = iokit_usb_err!(0x49);
43pub const kIOUSBDeviceTransferredToCompanion: c_uint = iokit_usb_err!(0x49);
45pub const kIOUSBClearPipeStallNotRecursive: c_uint = iokit_usb_err!(0x48);
47pub const kIOUSBDevicePortWasNotSuspended: c_uint = iokit_usb_err!(0x47);
49pub const kIOUSBEndpointCountExceeded: c_uint = iokit_usb_err!(0x46);
51pub const kIOUSBDeviceCountExceeded: c_uint = iokit_usb_err!(0x45);
53pub const kIOUSBStreamsNotSupported: c_uint = iokit_usb_err!(0x44);
55pub const kIOUSBInvalidSSEndpoint: c_uint = iokit_usb_err!(0x43);
57pub const kIOUSBTooManyTransactionsPending: c_uint = iokit_usb_err!(0x42);
59pub const kIOUSBTransactionReturned: c_uint = iokit_usb_err!(0x50);
61pub const kIOUSBTransactionTimeout: c_uint = iokit_usb_err!(0x51);
63pub const kIOUSBLinkErr: c_uint = iokit_usb_err!(0x10);
65pub const kIOUSBNotSent2Err: c_uint = iokit_usb_err!(0x0f);
67pub const kIOUSBNotSent1Err: c_uint = iokit_usb_err!(0x0e);
69pub const kIOUSBBufferUnderrunErr: c_uint = iokit_usb_err!(0x0d);
71pub const kIOUSBBufferOverrunErr: c_uint = iokit_usb_err!(0x0c);
73pub const kIOUSBReserved2Err: c_uint = iokit_usb_err!(0x0b);
75pub const kIOUSBReserved1Err: c_uint = iokit_usb_err!(0x0a);
77pub const kIOUSBWrongPIDErr: c_uint = iokit_usb_err!(0x07);
79pub const kIOUSBPIDCheckErr: c_uint = iokit_usb_err!(0x06);
81pub const kIOUSBDataToggleErr: c_uint = iokit_usb_err!(0x03);
83pub const kIOUSBBitstufErr: c_uint = iokit_usb_err!(0x02);
85pub const kIOUSBCRCErr: c_uint = iokit_usb_err!(0x01);
87pub const kIOUSBMessageHubResetPort: c_uint = iokit_usb_msg!(0x01);
89pub const kIOUSBMessageHubSuspendPort: c_uint = iokit_usb_msg!(0x02);
91pub const kIOUSBMessageHubResumePort: c_uint = iokit_usb_msg!(0x03);
93pub const kIOUSBMessageHubIsDeviceConnected: c_uint = iokit_usb_msg!(0x04);
95pub const kIOUSBMessageHubIsPortEnabled: c_uint = iokit_usb_msg!(0x05);
97pub const kIOUSBMessageHubReEnumeratePort: c_uint = iokit_usb_msg!(0x06);
99pub const kIOUSBMessagePortHasBeenReset: c_uint = iokit_usb_msg!(0x0a);
101pub const kIOUSBMessagePortHasBeenResumed: c_uint = iokit_usb_msg!(0x0b);
103pub const kIOUSBMessageHubPortClearTT: c_uint = iokit_usb_msg!(0x0c);
105pub const kIOUSBMessagePortHasBeenSuspended: c_uint = iokit_usb_msg!(0x0d);
107pub const kIOUSBMessageFromThirdParty: c_uint = iokit_usb_msg!(0x0e);
109pub const kIOUSBMessagePortWasNotSuspended: c_uint = iokit_usb_msg!(0x0f);
111pub const kIOUSBMessageExpressCardCantWake: c_uint = iokit_usb_msg!(0x10);
113pub const kIOUSBMessageCompositeDriverReconfigured: c_uint = iokit_usb_msg!(0x11);
115pub const kIOUSBMessageHubSetPortRecoveryTime: c_uint = iokit_usb_msg!(0x12);
117pub const kIOUSBMessageOvercurrentCondition: c_uint = iokit_usb_msg!(0x13);
119pub const kIOUSBMessageNotEnoughPower: c_uint = iokit_usb_msg!(0x14);
121pub const kIOUSBMessageController: c_uint = iokit_usb_msg!(0x15);
123pub const kIOUSBMessageRootHubWakeEvent: c_uint = iokit_usb_msg!(0x16);
125pub const kIOUSBMessageReleaseExtraCurrent: c_uint = iokit_usb_msg!(0x17);
127pub const kIOUSBMessageReallocateExtraCurrent: c_uint = iokit_usb_msg!(0x18);
129pub const kIOUSBMessageEndpointCountExceeded: c_uint = iokit_usb_msg!(0x19);
131pub const kIOUSBMessageDeviceCountExceeded: c_uint = iokit_usb_msg!(0x1a);
133pub const kIOUSBMessageHubPortDeviceDisconnected: c_uint = iokit_usb_msg!(0x1b);
135pub const kIOUSBMessageUnsupportedConfiguration: c_uint = iokit_usb_msg!(0x1c);
137pub const kIOUSBMessageHubCountExceeded: c_uint = iokit_usb_msg!(0x1d);
139pub const kIOUSBMessageTDMLowBattery: c_uint = iokit_usb_msg!(0x1e);
141pub const kIOUSBMessageLegacySuspendDevice: c_uint = iokit_usb_msg!(0x1f);
143pub const kIOUSBMessageLegacyResetDevice: c_uint = iokit_usb_msg!(0x20);
145pub const kIOUSBMessageLegacyReEnumerateDevice: c_uint = iokit_usb_msg!(0x21);
147pub const kIOUSBMessageConfigurationSet: c_uint = iokit_usb_msg!(0x22);
149pub const kUSBDevicePropertyBusPowerAvailable: &CStr =
151 unsafe { CStr::from_bytes_with_nul_unchecked(b"Bus Power Available\0") };
152#[cfg(feature = "IOUSBHostFamilyDefinitions")]
154pub const kUSBDevicePropertyLocationID: &CStr = kUSBHostPropertyLocationID;
155#[cfg(feature = "IOUSBHostFamilyDefinitions")]
157pub const kUSBProductIDMask: &CStr = kUSBHostMatchingPropertyProductIDMask;
158#[cfg(feature = "IOUSBHostFamilyDefinitions")]
160pub const kUSBProductIdsArrayName: &CStr = kUSBHostMatchingPropertyProductIDArray;
161pub const kUSBSuspendPort: &CStr =
163 unsafe { CStr::from_bytes_with_nul_unchecked(b"kSuspendPort\0") };
164pub const kUSBExpressCardCantWake: &CStr =
166 unsafe { CStr::from_bytes_with_nul_unchecked(b"ExpressCardCantWake\0") };
167#[cfg(feature = "IOUSBHostFamilyDefinitions")]
169pub const kUSBDeviceResumeRecoveryTime: &CStr = kUSBHostDevicePropertyResumeRecoveryTime;
170pub const kUSBOutOfSpecMPSOK: &CStr =
172 unsafe { CStr::from_bytes_with_nul_unchecked(b"Out of spec MPS OK\0") };
173pub const kOverrideIfAtLocationID: &CStr =
175 unsafe { CStr::from_bytes_with_nul_unchecked(b"OverrideIfAtLocationID\0") };
176#[cfg(feature = "IOUSBHostFamilyDefinitions")]
178pub const kUSBDeviceCurrentConfiguration: &CStr = kUSBHostDevicePropertyCurrentConfiguration;
179#[cfg(feature = "IOUSBHostFamilyDefinitions")]
181pub const kUSBDeviceRemoteWakeOverride: &CStr = kUSBHostDevicePropertyRemoteWakeOverride;
182#[cfg(feature = "IOUSBHostFamilyDefinitions")]
184pub const kUSBDeviceConfigurationCurrentOverride: &CStr =
185 kUSBHostDevicePropertyConfigurationCurrentOverride;
186#[cfg(feature = "IOUSBHostFamilyDefinitions")]
188pub const kUSBDeviceResetDurationOverride: &CStr = kUSBHostDevicePropertyResetDurationOverride;
189#[cfg(feature = "IOUSBHostFamilyDefinitions")]
191pub const kUSBDeviceFailedRequestedPower: &CStr = kUSBHostDevicePropertyFailedRequestedPower;
192#[cfg(feature = "IOUSBHostFamilyDefinitions")]
194pub const kUSBPropertyRemovable: &CStr = kUSBHostPortPropertyRemovable;
195#[cfg(feature = "IOUSBHostFamilyDefinitions")]
197pub const kUSBPropertyTestMode: &CStr = kUSBHostPortPropertyTestMode;
198#[cfg(feature = "IOUSBHostFamilyDefinitions")]
200pub const kUSBPropertyDebugLevel: &CStr = kUSBHostPropertyDebugOptions;
201#[cfg(feature = "IOUSBHostFamilyDefinitions")]
203pub const kUSBHubPropertyPowerSupply: &CStr = kUSBHostHubPropertyPowerSupply;
204#[cfg(feature = "IOUSBHostFamilyDefinitions")]
206pub const kUSBControllerSleepSupported: &CStr = kUSBHostControllerPropertySleepSupported;
207#[cfg(feature = "IOUSBHostFamilyDefinitions")]
209pub const kUSBPortPropertyBusCurrentAllocation: &CStr = kUSBHostPortPropertyBusCurrentAllocation;
210pub const kUSBPreferredInterface: &CStr =
212 unsafe { CStr::from_bytes_with_nul_unchecked(b"Preferred Interface\0") };
213pub const kUSBPreferredInterfacePriority: &CStr =
215 unsafe { CStr::from_bytes_with_nul_unchecked(b"priority\0") };
216pub const kOverrideAllowLowPower: &CStr =
218 unsafe { CStr::from_bytes_with_nul_unchecked(b"kOverrideAllowLowPower\0") };
219pub const kUSBUserClientEntitlementRequired: &CStr =
221 unsafe { CStr::from_bytes_with_nul_unchecked(b"UsbUserClientEntitlementRequired\0") };
222pub const kUSBDevicePropertySpeed: &CStr =
224 unsafe { CStr::from_bytes_with_nul_unchecked(b"Device Speed\0") };
225pub const kUSBDevicePropertyAddress: &CStr =
227 unsafe { CStr::from_bytes_with_nul_unchecked(b"USB Address\0") };
228pub const kUSBPreferredConfiguration: &CStr =
230 unsafe { CStr::from_bytes_with_nul_unchecked(b"Preferred Configuration\0") };
231pub const kUSBControllerNeedsContiguousMemoryForIsoch: &CStr =
233 unsafe { CStr::from_bytes_with_nul_unchecked(b"Need contiguous memory for isoch\0") };
234pub const kUSBHubDontAllowLowPower: &CStr =
236 unsafe { CStr::from_bytes_with_nul_unchecked(b"kUSBHubDontAllowLowPower\0") };
237pub const kConfigurationDescriptorOverride: &CStr =
239 unsafe { CStr::from_bytes_with_nul_unchecked(b"ConfigurationDescriptorOverride\0") };
240pub const kAppleRevocableExtraCurrent: &CStr =
242 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,revocable-extra-current\0") };
243pub const kAppleExternalSuperSpeedPorts: &CStr =
245 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,ExternalSSPorts\0") };
246pub const kAppleUnconnectedSuperSpeedPorts: &CStr =
248 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,UnconnectedSSPorts\0") };
249pub const kAppleAcpiRootHubDepth: &CStr =
251 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,root-hub-depth\0") };
252pub const kAppleStandardPortCurrentInSleep: &CStr =
254 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,standard-port-current-in-sleep\0") };
255pub const kAppleInternalUSBDevice: &CStr =
257 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,device-internal\0") };
258pub const kUSBBusID: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,bus-id\0") };
260pub const kApplePowerSupply: &CStr =
262 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,power-supply\0") };
263pub const kAppleCurrentAvailable: &CStr =
265 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,current-available\0") };
266pub const kAppleCurrentInSleep: &CStr =
268 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,current-in-sleep\0") };
269pub const kApplePortCurrentInSleep: &CStr =
271 unsafe { CStr::from_bytes_with_nul_unchecked(b"AAPL,port-current-in-sleep\0") };
272pub const kOverrideAttachedToCPU: &CStr =
274 unsafe { CStr::from_bytes_with_nul_unchecked(b"kOverrideAttachedToCPU\0") };
275pub const kEHCIIsochMaxBusStall: c_uint = 25000;
277pub const kXHCIIsochMaxBusStall: c_uint = 25000;
279pub const kOHCIIsochMaxBusStall: c_uint = 25000;
281pub const kUHCIIsochMaxBusStall: c_uint = 10000;
283pub const kMaxBusStall10uS: c_uint = 10000;
285pub const kMaxBusStall25uS: c_uint = 25000;
287pub const kUSBDeviceIDShift: c_long = 7;
289pub const kUSBMaxDevices: c_long = 128;
291pub const kUSBMaxDevice: c_long = kUSBMaxDevices - 1;
293pub const kUSBDeviceIDMask: c_long = 0x7f;
295pub const kUSBTooManyDevicesAddress: c_long = 0xfffe;
297pub const kUSBPipeIDMask: c_long = 0xf;
299pub const kUSBMaxPipes: c_long = 32;
301pub const kUSBInterfaceIDShift: c_long = 8;
303pub const kUSBMaxInterfaces: c_long = 1 << kUSBInterfaceIDShift;
305pub const kUSBInterfaceIDMask: c_long = kUSBMaxInterfaces - 1;
307pub const kUSBEndPtShift: c_long = 7;
309pub const kUSBDeviceMask: c_long = (1 << kUSBEndPtShift) - 1;
311pub const kUSBNoPipeIdx: c_long = -1;
313pub const kUSBUCRequestWithoutUSBNotificationMask: c_long = 1 << 30;
315pub const kUSBEndpointTransferTypeUCMask: c_long = 1 << 7;
317pub const kUSBStream0: c_long = 0;
319pub const kUSBMaxStream: c_long = 65533;
321pub const kUSBPRimeStream: c_long = 0xfffe;
323pub const kUSBNoStream: c_long = 0xffff;
325pub const kUSBStreamIDMask: c_long = 0xffff;
327pub const kUSBStreamIDAllStreamsMask: c_long = 1 << 31;
329
330#[cfg(feature = "AppleUSBDefinitions")]
332pub const kUSBRqDirnShift: c_uint = tIOUSBDeviceRequest::IOUSBDeviceRequestDirectionPhase.0;
333pub const kUSBRqDirnMask: c_uint = 1;
335#[cfg(feature = "AppleUSBDefinitions")]
337pub const kUSBRqTypeShift: c_uint = tIOUSBDeviceRequest::IOUSBDeviceRequestTypePhase.0;
338pub const kUSBRqTypeMask: c_uint = 3;
340#[cfg(feature = "AppleUSBDefinitions")]
342pub const kUSBRqRecipientMask: c_uint = tIOUSBDeviceRequest::IOUSBDeviceRequestRecipientMask.0;
343
344pub const kUSBMaxFSIsocEndpointReqCount: c_uint = 1023;
346pub const kUSBMaxHSIsocEndpointReqCount: c_uint = 3072;
348pub const kUSBMaxHSIsocFrameCount: c_uint = 7168;
350
351#[cfg(feature = "USBSpec")]
353pub const kClearDeviceFeature: c_uint =
354 EncodeRequest!(kUSBRqClearFeature, kUSBOut, kUSBStandard, kUSBDevice);
355#[cfg(feature = "USBSpec")]
357pub const kClearInterfaceFeature: c_uint =
358 EncodeRequest!(kUSBRqClearFeature, kUSBOut, kUSBStandard, kUSBInterface);
359#[cfg(feature = "USBSpec")]
361pub const kClearEndpointFeature: c_uint =
362 EncodeRequest!(kUSBRqClearFeature, kUSBOut, kUSBStandard, kUSBEndpoint);
363#[cfg(feature = "USBSpec")]
365pub const kGetConfiguration: c_uint =
366 EncodeRequest!(kUSBRqGetConfig, kUSBIn, kUSBStandard, kUSBDevice);
367#[cfg(feature = "USBSpec")]
369pub const kGetDescriptor: c_uint =
370 EncodeRequest!(kUSBRqGetDescriptor, kUSBIn, kUSBStandard, kUSBDevice);
371#[cfg(feature = "USBSpec")]
373pub const kGetInterface: c_uint =
374 EncodeRequest!(kUSBRqGetInterface, kUSBIn, kUSBStandard, kUSBInterface);
375#[cfg(feature = "USBSpec")]
377pub const kGetDeviceStatus: c_uint =
378 EncodeRequest!(kUSBRqGetStatus, kUSBIn, kUSBStandard, kUSBDevice);
379#[cfg(feature = "USBSpec")]
381pub const kGetInterfaceStatus: c_uint =
382 EncodeRequest!(kUSBRqGetStatus, kUSBIn, kUSBStandard, kUSBInterface);
383#[cfg(feature = "USBSpec")]
385pub const kGetEndpointStatus: c_uint =
386 EncodeRequest!(kUSBRqGetStatus, kUSBIn, kUSBStandard, kUSBEndpoint);
387#[cfg(feature = "USBSpec")]
389pub const kSetAddress: c_uint = EncodeRequest!(kUSBRqSetAddress, kUSBOut, kUSBStandard, kUSBDevice);
390#[cfg(feature = "USBSpec")]
392pub const kSetConfiguration: c_uint =
393 EncodeRequest!(kUSBRqSetConfig, kUSBOut, kUSBStandard, kUSBDevice);
394#[cfg(feature = "USBSpec")]
396pub const kSetDescriptor: c_uint =
397 EncodeRequest!(kUSBRqSetDescriptor, kUSBOut, kUSBStandard, kUSBDevice);
398#[cfg(feature = "USBSpec")]
400pub const kSetDeviceFeature: c_uint =
401 EncodeRequest!(kUSBRqSetFeature, kUSBOut, kUSBStandard, kUSBDevice);
402#[cfg(feature = "USBSpec")]
404pub const kSetInterfaceFeature: c_uint =
405 EncodeRequest!(kUSBRqSetFeature, kUSBOut, kUSBStandard, kUSBInterface);
406#[cfg(feature = "USBSpec")]
408pub const kSetEndpointFeature: c_uint =
409 EncodeRequest!(kUSBRqSetFeature, kUSBOut, kUSBStandard, kUSBEndpoint);
410#[cfg(feature = "USBSpec")]
412pub const kSetInterface: c_uint =
413 EncodeRequest!(kUSBRqSetInterface, kUSBOut, kUSBStandard, kUSBInterface);
414#[cfg(feature = "USBSpec")]
416pub const kSyncFrame: c_uint = EncodeRequest!(kUSBRqSyncFrame, kUSBIn, kUSBStandard, kUSBEndpoint);
417
418pub type USBDeviceAddress = u16;
420
421pub type USBPhysicalAddress32 = u32;
423
424#[repr(C)]
434#[derive(Clone, Copy, Debug, PartialEq)]
435pub struct IOUSBIsocFrame {
436 pub frStatus: IOReturn,
437 pub frReqCount: u16,
438 pub frActCount: u16,
439}
440
441#[cfg(feature = "objc2")]
442unsafe impl Encode for IOUSBIsocFrame {
443 const ENCODING: Encoding = Encoding::Struct(
444 "IOUSBIsocFrame",
445 &[<IOReturn>::ENCODING, <u16>::ENCODING, <u16>::ENCODING],
446 );
447}
448
449#[cfg(feature = "objc2")]
450unsafe impl RefEncode for IOUSBIsocFrame {
451 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
452}
453
454#[repr(C)]
467#[derive(Clone, Copy, Debug, PartialEq)]
468pub struct IOUSBLowLatencyIsocFrame {
469 pub frStatus: IOReturn,
470 pub frReqCount: u16,
471 pub frActCount: u16,
472 pub frTimeStamp: AbsoluteTime,
473}
474
475#[cfg(feature = "objc2")]
476unsafe impl Encode for IOUSBLowLatencyIsocFrame {
477 const ENCODING: Encoding = Encoding::Struct(
478 "IOUSBLowLatencyIsocFrame",
479 &[
480 <IOReturn>::ENCODING,
481 <u16>::ENCODING,
482 <u16>::ENCODING,
483 <AbsoluteTime>::ENCODING,
484 ],
485 );
486}
487
488#[cfg(feature = "objc2")]
489unsafe impl RefEncode for IOUSBLowLatencyIsocFrame {
490 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
491}
492
493pub type IOUSBCompletionAction =
505 Option<unsafe extern "C-unwind" fn(*mut c_void, *mut c_void, IOReturn, u32)>;
506
507pub type IOUSBCompletionActionWithTimeStamp =
521 Option<unsafe extern "C-unwind" fn(*mut c_void, *mut c_void, IOReturn, u32, AbsoluteTime)>;
522
523pub type IOUSBIsocCompletionAction =
535 Option<unsafe extern "C-unwind" fn(*mut c_void, *mut c_void, IOReturn, *mut IOUSBIsocFrame)>;
536
537pub type IOUSBLowLatencyIsocCompletionAction = Option<
549 unsafe extern "C-unwind" fn(*mut c_void, *mut c_void, IOReturn, *mut IOUSBLowLatencyIsocFrame),
550>;
551
552#[repr(C)]
562#[allow(unpredictable_function_pointer_comparisons)]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub struct IOUSBCompletion {
565 pub target: *mut c_void,
566 pub action: IOUSBCompletionAction,
567 pub parameter: *mut c_void,
568}
569
570#[cfg(feature = "objc2")]
571unsafe impl Encode for IOUSBCompletion {
572 const ENCODING: Encoding = Encoding::Struct(
573 "IOUSBCompletion",
574 &[
575 <*mut c_void>::ENCODING,
576 <IOUSBCompletionAction>::ENCODING,
577 <*mut c_void>::ENCODING,
578 ],
579 );
580}
581
582#[cfg(feature = "objc2")]
583unsafe impl RefEncode for IOUSBCompletion {
584 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
585}
586
587#[repr(C)]
597#[allow(unpredictable_function_pointer_comparisons)]
598#[derive(Clone, Copy, Debug, PartialEq)]
599pub struct IOUSBCompletionWithTimeStamp {
600 pub target: *mut c_void,
601 pub action: IOUSBCompletionActionWithTimeStamp,
602 pub parameter: *mut c_void,
603}
604
605#[cfg(feature = "objc2")]
606unsafe impl Encode for IOUSBCompletionWithTimeStamp {
607 const ENCODING: Encoding = Encoding::Struct(
608 "IOUSBCompletionWithTimeStamp",
609 &[
610 <*mut c_void>::ENCODING,
611 <IOUSBCompletionActionWithTimeStamp>::ENCODING,
612 <*mut c_void>::ENCODING,
613 ],
614 );
615}
616
617#[cfg(feature = "objc2")]
618unsafe impl RefEncode for IOUSBCompletionWithTimeStamp {
619 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
620}
621
622#[repr(C)]
632#[allow(unpredictable_function_pointer_comparisons)]
633#[derive(Clone, Copy, Debug, PartialEq)]
634pub struct IOUSBIsocCompletion {
635 pub target: *mut c_void,
636 pub action: IOUSBIsocCompletionAction,
637 pub parameter: *mut c_void,
638}
639
640#[cfg(feature = "objc2")]
641unsafe impl Encode for IOUSBIsocCompletion {
642 const ENCODING: Encoding = Encoding::Struct(
643 "IOUSBIsocCompletion",
644 &[
645 <*mut c_void>::ENCODING,
646 <IOUSBIsocCompletionAction>::ENCODING,
647 <*mut c_void>::ENCODING,
648 ],
649 );
650}
651
652#[cfg(feature = "objc2")]
653unsafe impl RefEncode for IOUSBIsocCompletion {
654 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
655}
656
657#[repr(C)]
667#[allow(unpredictable_function_pointer_comparisons)]
668#[derive(Clone, Copy, Debug, PartialEq)]
669pub struct IOUSBLowLatencyIsocCompletion {
670 pub target: *mut c_void,
671 pub action: IOUSBLowLatencyIsocCompletionAction,
672 pub parameter: *mut c_void,
673}
674
675#[cfg(feature = "objc2")]
676unsafe impl Encode for IOUSBLowLatencyIsocCompletion {
677 const ENCODING: Encoding = Encoding::Struct(
678 "IOUSBLowLatencyIsocCompletion",
679 &[
680 <*mut c_void>::ENCODING,
681 <IOUSBLowLatencyIsocCompletionAction>::ENCODING,
682 <*mut c_void>::ENCODING,
683 ],
684 );
685}
686
687#[cfg(feature = "objc2")]
688unsafe impl RefEncode for IOUSBLowLatencyIsocCompletion {
689 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
690}
691
692#[repr(C)]
694#[derive(Clone, Copy, Debug, PartialEq)]
695pub struct IOUSBMouseData {
696 pub buttons: u16,
697 pub XDelta: i16,
698 pub YDelta: i16,
699}
700
701#[cfg(feature = "objc2")]
702unsafe impl Encode for IOUSBMouseData {
703 const ENCODING: Encoding = Encoding::Struct(
704 "IOUSBMouseData",
705 &[<u16>::ENCODING, <i16>::ENCODING, <i16>::ENCODING],
706 );
707}
708
709#[cfg(feature = "objc2")]
710unsafe impl RefEncode for IOUSBMouseData {
711 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
712}
713
714pub type IOUSBMouseDataPtr = *mut IOUSBMouseData;
716
717#[repr(C)]
719#[derive(Clone, Copy, Debug, PartialEq)]
720pub struct IOUSBKeyboardData {
721 pub keycount: u16,
722 pub usbkeycode: [u16; 32],
723}
724
725#[cfg(feature = "objc2")]
726unsafe impl Encode for IOUSBKeyboardData {
727 const ENCODING: Encoding = Encoding::Struct(
728 "IOUSBKeyboardData",
729 &[<u16>::ENCODING, <[u16; 32]>::ENCODING],
730 );
731}
732
733#[cfg(feature = "objc2")]
734unsafe impl RefEncode for IOUSBKeyboardData {
735 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
736}
737
738pub type IOUSBKeyboardDataPtr = *mut IOUSBKeyboardData;
740
741#[repr(C)]
743#[derive(Clone, Copy)]
744pub union IOUSBHIDData {
745 pub kbd: IOUSBKeyboardData,
746 pub mouse: IOUSBMouseData,
747}
748
749#[cfg(feature = "objc2")]
750unsafe impl Encode for IOUSBHIDData {
751 const ENCODING: Encoding = Encoding::Union(
752 "IOUSBHIDData",
753 &[<IOUSBKeyboardData>::ENCODING, <IOUSBMouseData>::ENCODING],
754 );
755}
756
757#[cfg(feature = "objc2")]
758unsafe impl RefEncode for IOUSBHIDData {
759 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
760}
761
762pub type IOUSBHIDDataPtr = *mut IOUSBHIDData;
764
765#[cfg(feature = "AppleUSBDefinitions")]
767pub type IOUSBDeviceDescriptorPtr = *mut IOUSBDeviceDescriptor;
768
769#[cfg(feature = "AppleUSBDefinitions")]
771pub type IOUSBDescriptorHeaderPtr = *mut IOUSBDescriptorHeader;
772
773#[cfg(feature = "AppleUSBDefinitions")]
775pub type IOUSBBOSDescriptorPtr = *mut IOUSBBOSDescriptor;
776
777#[cfg(feature = "AppleUSBDefinitions")]
779pub type IOUSBDeviceCapabilityDescriptorHeaderPtr = *mut IOUSBDeviceCapabilityDescriptorHeader;
780
781#[cfg(feature = "AppleUSBDefinitions")]
783pub type IOUSBDeviceCapabilityUSB2ExtensionPtr = *mut IOUSBDeviceCapabilityUSB2Extension;
784
785#[cfg(feature = "AppleUSBDefinitions")]
787pub type IOUSBDeviceCapabilitySuperSpeedUSBPtr = *mut IOUSBDeviceCapabilitySuperSpeedUSB;
788
789#[cfg(feature = "AppleUSBDefinitions")]
791pub type IOUSBDeviceCapabilitySuperSpeedPlusUSBPtr = *mut IOUSBDeviceCapabilitySuperSpeedPlusUSB;
792
793#[cfg(feature = "AppleUSBDefinitions")]
795pub type IOUSBDeviceCapabilityContainerIDPtr = *mut IOUSBDeviceCapabilityContainerID;
796
797#[cfg(feature = "AppleUSBDefinitions")]
799pub type IOUSBPlatformCapabilityDescriptorPtr = *mut IOUSBPlatformCapabilityDescriptor;
800
801#[cfg(feature = "AppleUSBDefinitions")]
803pub type IOUSBDeviceCapabilityBillboardAltConfigPtr = *mut IOUSBDeviceCapabilityBillboardAltConfig;
804
805#[cfg(feature = "AppleUSBDefinitions")]
807pub type IOUSBDeviceCapabilityBillboardPtr = *mut IOUSBDeviceCapabilityBillboard;
808
809#[cfg(feature = "AppleUSBDefinitions")]
811pub type IOUSBDeviceCapabilityBillboardAltModePtr = *mut IOUSBDeviceCapabilityBillboardAltMode;
812
813#[cfg(feature = "AppleUSBDefinitions")]
815pub type IOUSBConfigurationDescriptorPtr = *mut IOUSBConfigurationDescriptor;
816
817#[cfg(feature = "AppleUSBDefinitions")]
819pub type IOUSBConfigurationDescHeaderPtr = *mut IOUSBConfigurationDescHeader;
820
821#[cfg(feature = "AppleUSBDefinitions")]
823pub type IOUSBInterfaceDescriptorPtr = *mut IOUSBInterfaceDescriptor;
824
825#[cfg(feature = "AppleUSBDefinitions")]
827pub type IOUSBEndpointDescriptorPtr = *mut IOUSBEndpointDescriptor;
828
829#[cfg(feature = "AppleUSBDefinitions")]
831pub type IOUSBStringDescriptorPtr = *mut IOUSBStringDescriptor;
832
833#[cfg(feature = "AppleUSBDefinitions")]
835pub type IOUSBSuperSpeedEndpointCompanionDescriptorPtr =
836 *mut IOUSBSuperSpeedEndpointCompanionDescriptor;
837
838#[cfg(feature = "AppleUSBDefinitions")]
840pub type IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptorPtr =
841 *mut IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptor;
842
843#[cfg(feature = "AppleUSBDefinitions")]
845pub type UASPipeDescriptorPtr = *mut UASPipeDescriptor;
846
847#[cfg(feature = "AppleUSBDefinitions")]
849pub type IOUSBHIDDescriptorPtr = *mut IOUSBHIDDescriptor;
850
851#[cfg(feature = "AppleUSBDefinitions")]
853pub type IOUSBHIDReportDescPtr = *mut IOUSBHIDReportDesc;
854
855#[cfg(feature = "AppleUSBDefinitions")]
857pub type IOUSBDeviceQualifierDescriptorPtr = *mut IOUSBDeviceQualifierDescriptor;
858
859#[cfg(feature = "AppleUSBDefinitions")]
861pub type IOUSBDFUDescriptorPtr = *mut IOUSBDFUDescriptor;
862
863#[cfg(feature = "AppleUSBDefinitions")]
865pub type IOUSBInterfaceAssociationDescriptorPtr = *mut IOUSBInterfaceAssociationDescriptor;
866
867pub const kIOUSBDeviceCapabilityDescriptorType: c_uint = 16;
869pub const kIOUSBDeviceCapabilityDescriptorLengthMin: c_uint = 3;
871
872pub const kUSB_EPDesc_bmAttributes_TranType_Mask: c_uint = USBBitRange!(0, 1);
874pub const kUSB_EPDesc_bmAttributes_TranType_Shift: c_uint = USBBitRangePhase!(0, 1);
876pub const kUSB_EPDesc_bmAttributes_SyncType_Mask: c_uint = USBBitRange!(2, 3);
878pub const kUSB_EPDesc_bmAttributes_SyncType_Shift: c_uint = USBBitRangePhase!(2, 3);
880pub const kUSB_EPDesc_bmAttributes_UsageType_Mask: c_uint = USBBitRange!(4, 5);
882pub const kUSB_EPDesc_bmAttributes_UsageType_Shift: c_uint = USBBitRangePhase!(4, 5);
884pub const kUSB_EPDesc_wMaxPacketSize_MPS_Mask: c_uint = USBBitRange!(0, 10);
886pub const kUSB_EPDesc_wMaxPacketSize_MPS_Shift: c_uint = USBBitRangePhase!(0, 10);
888pub const kUSB_EPDesc_MaxMPS: c_uint = 1024;
890pub const kUSB_HSFSEPDesc_wMaxPacketSize_Mult_Mask: c_uint = USBBitRange!(11, 12);
892pub const kUSB_HSFSEPDesc_wMaxPacketSize_Mult_Shift: c_uint = USBBitRangePhase!(11, 12);
894
895pub const kUSB_SSCompDesc_Bulk_MaxStreams_Mask: c_uint = USBBitRange!(0, 4);
897pub const kUSB_SSCompDesc_Bulk_MaxStreams_Shift: c_uint = USBBitRangePhase!(0, 4);
899pub const kUSB_SSCompDesc_Isoc_Mult_Mask: c_uint = USBBitRange!(0, 1);
901pub const kUSB_SSCompDesc_Isoc_Mult_Shift: c_uint = USBBitRangePhase!(0, 1);
903
904pub const addPacketShift: c_uint = 11;
906
907#[repr(C, packed)]
924#[derive(Clone, Copy, Debug, PartialEq)]
925pub struct IOUSBEndpointProperties {
926 pub bVersion: u8,
927 pub bAlternateSetting: u8,
928 pub bDirection: u8,
929 pub bEndpointNumber: u8,
930 pub bTransferType: u8,
931 pub bUsageType: u8,
932 pub bSyncType: u8,
933 pub bInterval: u8,
934 pub wMaxPacketSize: u16,
935 pub bMaxBurst: u8,
936 pub bMaxStreams: u8,
937 pub bMult: u8,
938 pub wBytesPerInterval: u16,
939}
940
941#[cfg(feature = "objc2")]
942unsafe impl Encode for IOUSBEndpointProperties {
943 const ENCODING: Encoding = Encoding::Struct(
944 "IOUSBEndpointProperties",
945 &[
946 <u8>::ENCODING,
947 <u8>::ENCODING,
948 <u8>::ENCODING,
949 <u8>::ENCODING,
950 <u8>::ENCODING,
951 <u8>::ENCODING,
952 <u8>::ENCODING,
953 <u8>::ENCODING,
954 <u16>::ENCODING,
955 <u8>::ENCODING,
956 <u8>::ENCODING,
957 <u8>::ENCODING,
958 <u16>::ENCODING,
959 ],
960 );
961}
962
963#[cfg(feature = "objc2")]
964unsafe impl RefEncode for IOUSBEndpointProperties {
965 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
966}
967
968pub type IOUSBEndpointPropertiesPtr = *mut IOUSBEndpointProperties;
970
971pub const kUSBEndpointPropertiesVersion3: c_uint = 0x03;
973
974pub type USBStatus = u16;
978
979pub type USBStatusPtr = *mut USBStatus;
981
982pub const kIOUSBAnyClass: c_uint = 0xFFFF;
984pub const kIOUSBAnySubClass: c_uint = 0xFFFF;
986pub const kIOUSBAnyProtocol: c_uint = 0xFFFF;
988pub const kIOUSBAnyVendor: c_uint = 0xFFFF;
990pub const kIOUSBAnyProduct: c_uint = 0xFFFF;
992
993#[repr(C)]
995#[derive(Clone, Copy, Debug, PartialEq)]
996pub struct IOUSBMatch {
997 pub usbClass: u16,
998 pub usbSubClass: u16,
999 pub usbProtocol: u16,
1000 pub usbVendor: u16,
1001 pub usbProduct: u16,
1002}
1003
1004#[cfg(feature = "objc2")]
1005unsafe impl Encode for IOUSBMatch {
1006 const ENCODING: Encoding = Encoding::Struct(
1007 "IOUSBMatch",
1008 &[
1009 <u16>::ENCODING,
1010 <u16>::ENCODING,
1011 <u16>::ENCODING,
1012 <u16>::ENCODING,
1013 <u16>::ENCODING,
1014 ],
1015 );
1016}
1017
1018#[cfg(feature = "objc2")]
1019unsafe impl RefEncode for IOUSBMatch {
1020 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1021}
1022
1023#[repr(C)]
1034#[derive(Clone, Copy, Debug, PartialEq)]
1035pub struct IOUSBFindEndpointRequest {
1036 pub r#type: u8,
1037 pub direction: u8,
1038 pub maxPacketSize: u16,
1039 pub interval: u8,
1040}
1041
1042#[cfg(feature = "objc2")]
1043unsafe impl Encode for IOUSBFindEndpointRequest {
1044 const ENCODING: Encoding = Encoding::Struct(
1045 "?",
1046 &[
1047 <u8>::ENCODING,
1048 <u8>::ENCODING,
1049 <u16>::ENCODING,
1050 <u8>::ENCODING,
1051 ],
1052 );
1053}
1054
1055#[cfg(feature = "objc2")]
1056unsafe impl RefEncode for IOUSBFindEndpointRequest {
1057 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1058}
1059
1060#[repr(C)]
1073#[derive(Clone, Copy, Debug, PartialEq)]
1074pub struct IOUSBDevRequest {
1075 pub bmRequestType: u8,
1076 pub bRequest: u8,
1077 pub wValue: u16,
1078 pub wIndex: u16,
1079 pub wLength: u16,
1080 pub pData: *mut c_void,
1081 pub wLenDone: u32,
1082}
1083
1084#[cfg(feature = "objc2")]
1085unsafe impl Encode for IOUSBDevRequest {
1086 const ENCODING: Encoding = Encoding::Struct(
1087 "?",
1088 &[
1089 <u8>::ENCODING,
1090 <u8>::ENCODING,
1091 <u16>::ENCODING,
1092 <u16>::ENCODING,
1093 <u16>::ENCODING,
1094 <*mut c_void>::ENCODING,
1095 <u32>::ENCODING,
1096 ],
1097 );
1098}
1099
1100#[cfg(feature = "objc2")]
1101unsafe impl RefEncode for IOUSBDevRequest {
1102 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1103}
1104
1105pub type IOUSBDeviceRequestPtr = *mut IOUSBDevRequest;
1107
1108#[repr(C)]
1123#[derive(Clone, Copy, Debug, PartialEq)]
1124pub struct IOUSBDevRequestTO {
1125 pub bmRequestType: u8,
1126 pub bRequest: u8,
1127 pub wValue: u16,
1128 pub wIndex: u16,
1129 pub wLength: u16,
1130 pub pData: *mut c_void,
1131 pub wLenDone: u32,
1132 pub noDataTimeout: u32,
1133 pub completionTimeout: u32,
1134}
1135
1136#[cfg(feature = "objc2")]
1137unsafe impl Encode for IOUSBDevRequestTO {
1138 const ENCODING: Encoding = Encoding::Struct(
1139 "?",
1140 &[
1141 <u8>::ENCODING,
1142 <u8>::ENCODING,
1143 <u16>::ENCODING,
1144 <u16>::ENCODING,
1145 <u16>::ENCODING,
1146 <*mut c_void>::ENCODING,
1147 <u32>::ENCODING,
1148 <u32>::ENCODING,
1149 <u32>::ENCODING,
1150 ],
1151 );
1152}
1153
1154#[cfg(feature = "objc2")]
1155unsafe impl RefEncode for IOUSBDevRequestTO {
1156 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1157}
1158
1159pub const kUSBDefaultControlNoDataTimeoutMS: c_uint = 5000;
1161pub const kUSBDefaultControlCompletionTimeoutMS: c_uint = 0;
1163
1164#[repr(C)]
1166#[derive(Clone, Copy, Debug, PartialEq)]
1167pub struct IOUSBBulkPipeReq {
1168 pub pipeRef: u32,
1169 pub buf: *mut c_void,
1170 pub size: u32,
1171 pub noDataTimeout: u32,
1172 pub completionTimeout: u32,
1173}
1174
1175#[cfg(feature = "objc2")]
1176unsafe impl Encode for IOUSBBulkPipeReq {
1177 const ENCODING: Encoding = Encoding::Struct(
1178 "?",
1179 &[
1180 <u32>::ENCODING,
1181 <*mut c_void>::ENCODING,
1182 <u32>::ENCODING,
1183 <u32>::ENCODING,
1184 <u32>::ENCODING,
1185 ],
1186 );
1187}
1188
1189#[cfg(feature = "objc2")]
1190unsafe impl RefEncode for IOUSBBulkPipeReq {
1191 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1192}
1193
1194#[repr(C)]
1196#[derive(Clone, Copy, Debug, PartialEq)]
1197pub struct IOUSBDevReqOOL {
1198 pub bmRequestType: u8,
1199 pub bRequest: u8,
1200 pub wValue: u16,
1201 pub wIndex: u16,
1202 pub wLength: u16,
1203 pub pData: *mut c_void,
1204 pub wLenDone: u32,
1205 pub pipeRef: u8,
1206}
1207
1208#[cfg(feature = "objc2")]
1209unsafe impl Encode for IOUSBDevReqOOL {
1210 const ENCODING: Encoding = Encoding::Struct(
1211 "?",
1212 &[
1213 <u8>::ENCODING,
1214 <u8>::ENCODING,
1215 <u16>::ENCODING,
1216 <u16>::ENCODING,
1217 <u16>::ENCODING,
1218 <*mut c_void>::ENCODING,
1219 <u32>::ENCODING,
1220 <u8>::ENCODING,
1221 ],
1222 );
1223}
1224
1225#[cfg(feature = "objc2")]
1226unsafe impl RefEncode for IOUSBDevReqOOL {
1227 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1228}
1229
1230#[repr(C)]
1232#[derive(Clone, Copy, Debug, PartialEq)]
1233pub struct IOUSBDevReqOOLTO {
1234 pub bmRequestType: u8,
1235 pub bRequest: u8,
1236 pub wValue: u16,
1237 pub wIndex: u16,
1238 pub wLength: u16,
1239 pub pData: *mut c_void,
1240 pub wLenDone: u32,
1241 pub pipeRef: u8,
1242 pub noDataTimeout: u32,
1243 pub completionTimeout: u32,
1244}
1245
1246#[cfg(feature = "objc2")]
1247unsafe impl Encode for IOUSBDevReqOOLTO {
1248 const ENCODING: Encoding = Encoding::Struct(
1249 "?",
1250 &[
1251 <u8>::ENCODING,
1252 <u8>::ENCODING,
1253 <u16>::ENCODING,
1254 <u16>::ENCODING,
1255 <u16>::ENCODING,
1256 <*mut c_void>::ENCODING,
1257 <u32>::ENCODING,
1258 <u8>::ENCODING,
1259 <u32>::ENCODING,
1260 <u32>::ENCODING,
1261 ],
1262 );
1263}
1264
1265#[cfg(feature = "objc2")]
1266unsafe impl RefEncode for IOUSBDevReqOOLTO {
1267 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1268}
1269
1270#[repr(C)]
1272#[derive(Clone, Copy, Debug, PartialEq)]
1273pub struct IOUSBIsocStruct {
1274 pub fPipe: u32,
1275 pub fBuffer: *mut c_void,
1276 pub fBufSize: u32,
1277 pub fStartFrame: u64,
1278 pub fNumFrames: u32,
1279 pub fFrameCounts: *mut IOUSBIsocFrame,
1280}
1281
1282#[cfg(feature = "objc2")]
1283unsafe impl Encode for IOUSBIsocStruct {
1284 const ENCODING: Encoding = Encoding::Struct(
1285 "?",
1286 &[
1287 <u32>::ENCODING,
1288 <*mut c_void>::ENCODING,
1289 <u32>::ENCODING,
1290 <u64>::ENCODING,
1291 <u32>::ENCODING,
1292 <*mut IOUSBIsocFrame>::ENCODING,
1293 ],
1294 );
1295}
1296
1297#[cfg(feature = "objc2")]
1298unsafe impl RefEncode for IOUSBIsocStruct {
1299 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1300}
1301
1302#[repr(C)]
1304#[derive(Clone, Copy, Debug, PartialEq)]
1305pub struct IOUSBLowLatencyIsocStruct {
1306 pub fPipe: u32,
1307 pub fBufSize: u32,
1308 pub fStartFrame: u64,
1309 pub fNumFrames: u32,
1310 pub fUpdateFrequency: u32,
1311 pub fDataBufferCookie: u32,
1312 pub fDataBufferOffset: u32,
1313 pub fFrameListBufferCookie: u32,
1314 pub fFrameListBufferOffset: u32,
1315}
1316
1317#[cfg(feature = "objc2")]
1318unsafe impl Encode for IOUSBLowLatencyIsocStruct {
1319 const ENCODING: Encoding = Encoding::Struct(
1320 "IOUSBLowLatencyIsocStruct",
1321 &[
1322 <u32>::ENCODING,
1323 <u32>::ENCODING,
1324 <u64>::ENCODING,
1325 <u32>::ENCODING,
1326 <u32>::ENCODING,
1327 <u32>::ENCODING,
1328 <u32>::ENCODING,
1329 <u32>::ENCODING,
1330 <u32>::ENCODING,
1331 ],
1332 );
1333}
1334
1335#[cfg(feature = "objc2")]
1336unsafe impl RefEncode for IOUSBLowLatencyIsocStruct {
1337 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1338}
1339
1340#[repr(C)]
1346#[derive(Clone, Copy, Debug, PartialEq)]
1347pub struct IOUSBGetFrameStruct {
1348 pub frame: u64,
1349 pub timeStamp: AbsoluteTime,
1350}
1351
1352#[cfg(feature = "objc2")]
1353unsafe impl Encode for IOUSBGetFrameStruct {
1354 const ENCODING: Encoding = Encoding::Struct("?", &[<u64>::ENCODING, <AbsoluteTime>::ENCODING]);
1355}
1356
1357#[cfg(feature = "objc2")]
1358unsafe impl RefEncode for IOUSBGetFrameStruct {
1359 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1360}
1361
1362#[repr(C)]
1366#[derive(Clone, Copy, Debug, PartialEq)]
1367pub struct IOUSBFindInterfaceRequest {
1368 pub bInterfaceClass: u16,
1369 pub bInterfaceSubClass: u16,
1370 pub bInterfaceProtocol: u16,
1371 pub bAlternateSetting: u16,
1372}
1373
1374#[cfg(feature = "objc2")]
1375unsafe impl Encode for IOUSBFindInterfaceRequest {
1376 const ENCODING: Encoding = Encoding::Struct(
1377 "?",
1378 &[
1379 <u16>::ENCODING,
1380 <u16>::ENCODING,
1381 <u16>::ENCODING,
1382 <u16>::ENCODING,
1383 ],
1384 );
1385}
1386
1387#[cfg(feature = "objc2")]
1388unsafe impl RefEncode for IOUSBFindInterfaceRequest {
1389 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1390}
1391
1392pub const kIOUSBFindInterfaceDontCare: c_uint = 0xFFFF;
1394
1395#[cfg(feature = "AppleUSBDefinitions")]
1397pub const kIOUSBVendorIDAppleComputer: c_uint = kIOUSBAppleVendorID;
1398#[cfg(feature = "AppleUSBDefinitions")]
1400pub const kIOUSBVendorIDApple: c_uint = kIOUSBAppleVendorID;
1401
1402pub const kUSBDeviceSpeedLow: c_uint = 0;
1404pub const kUSBDeviceSpeedFull: c_uint = 1;
1406pub const kUSBDeviceSpeedHigh: c_uint = 2;
1408pub const kUSBDeviceSpeedSuper: c_uint = 3;
1410pub const kUSBDeviceSpeedSuperPlus: c_uint = 4;
1412pub const kUSBDeviceSpeedSuperPlusBy2: c_uint = 5;
1414
1415pub const kUSBFullSpeedMicrosecondsInFrame: c_uint = 1000;
1417pub const kUSBHighSpeedMicrosecondsInFrame: c_uint = 125;
1419
1420pub const kUSBLowLatencyIsochTransferKey: c_uint = 0x6c6c6974;
1422
1423#[repr(transparent)]
1427#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1428pub struct USBLowLatencyBufferType(pub c_uint);
1429impl USBLowLatencyBufferType {
1430 #[doc(alias = "kUSBLowLatencyWriteBuffer")]
1431 pub const WriteBuffer: Self = Self(0);
1432 #[doc(alias = "kUSBLowLatencyReadBuffer")]
1433 pub const ReadBuffer: Self = Self(1);
1434 #[doc(alias = "kUSBLowLatencyFrameListBuffer")]
1435 pub const FrameListBuffer: Self = Self(2);
1436}
1437
1438#[cfg(feature = "objc2")]
1439unsafe impl Encode for USBLowLatencyBufferType {
1440 const ENCODING: Encoding = c_uint::ENCODING;
1441}
1442
1443#[cfg(feature = "objc2")]
1444unsafe impl RefEncode for USBLowLatencyBufferType {
1445 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1446}
1447
1448pub const kUSBNoUserNotificationType: c_uint = 0;
1450pub const kUSBNotEnoughPowerNotificationType: c_uint = 1;
1452pub const kUSBIndividualOverCurrentNotificationType: c_uint = 2;
1454pub const kUSBGangOverCurrentNotificationType: c_uint = 3;
1456pub const kUSBiOSDeviceNotEnoughPowerNotificationType: c_uint = 4;
1458pub const kUSBNotEnoughPowerNoACNotificationType: c_uint = 5;
1460pub const kUSBDeviceCountExceededNotificationType: c_uint = 6;
1462pub const kUSBEndpointCountExceededNotificationType: c_uint = 7;
1464pub const kUSBUnsupportedNotificationType: c_uint = 8;
1466pub const kUSBHubCountExceededNotificationType: c_uint = 9;
1468pub const kUSBTDMLowBatteryType: c_uint = 10;
1470pub const kUSBCTBNotEnoughPowerNotificationType: c_uint = 11;
1472pub const kUSBCTBUnsupportedNotificationType: c_uint = 12;
1474pub const kUSBCUnsupportedTBPortNotificationType: c_uint = 13;
1476pub const kUSBCUnsupportedTBCableNotificationType: c_uint = 14;
1478
1479#[repr(transparent)]
1486#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1487pub struct USBReEnumerateOptions(pub c_int);
1488impl USBReEnumerateOptions {
1489 #[doc(alias = "kUSBAddExtraResetTimeBit")]
1490 pub const AddExtraResetTimeBit: Self = Self(31);
1491 #[doc(alias = "kUSBReEnumerateCaptureDeviceBit")]
1492 pub const ReEnumerateCaptureDeviceBit: Self = Self(30);
1493 #[doc(alias = "kUSBReEnumerateReleaseDeviceBit")]
1494 pub const ReEnumerateReleaseDeviceBit: Self = Self(29);
1495 #[doc(alias = "kUSBAddExtraResetTimeMask")]
1496 pub const AddExtraResetTimeMask: Self =
1497 Self(1 << USBReEnumerateOptions::AddExtraResetTimeBit.0);
1498 #[doc(alias = "kUSBReEnumerateCaptureDeviceMask")]
1499 pub const ReEnumerateCaptureDeviceMask: Self =
1500 Self(1 << USBReEnumerateOptions::ReEnumerateCaptureDeviceBit.0);
1501 #[doc(alias = "kUSBReEnumerateReleaseDeviceMask")]
1502 pub const ReEnumerateReleaseDeviceMask: Self =
1503 Self(1 << USBReEnumerateOptions::ReEnumerateReleaseDeviceBit.0);
1504}
1505
1506#[cfg(feature = "objc2")]
1507unsafe impl Encode for USBReEnumerateOptions {
1508 const ENCODING: Encoding = c_int::ENCODING;
1509}
1510
1511#[cfg(feature = "objc2")]
1512unsafe impl RefEncode for USBReEnumerateOptions {
1513 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1514}
1515
1516#[repr(transparent)]
1520#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1521pub struct USBDeviceInformationBits(pub c_uint);
1522impl USBDeviceInformationBits {
1523 #[doc(alias = "kUSBInformationDeviceIsCaptiveBit")]
1524 pub const InformationDeviceIsCaptiveBit: Self = Self(0);
1525 #[doc(alias = "kUSBInformationDeviceIsAttachedToRootHubBit")]
1526 pub const InformationDeviceIsAttachedToRootHubBit: Self = Self(1);
1527 #[doc(alias = "kUSBInformationDeviceIsInternalBit")]
1528 pub const InformationDeviceIsInternalBit: Self = Self(2);
1529 #[doc(alias = "kUSBInformationDeviceIsConnectedBit")]
1530 pub const InformationDeviceIsConnectedBit: Self = Self(3);
1531 #[doc(alias = "kUSBInformationDeviceIsEnabledBit")]
1532 pub const InformationDeviceIsEnabledBit: Self = Self(4);
1533 #[doc(alias = "kUSBInformationDeviceIsSuspendedBit")]
1534 pub const InformationDeviceIsSuspendedBit: Self = Self(5);
1535 #[doc(alias = "kUSBInformationDeviceIsInResetBit")]
1536 pub const InformationDeviceIsInResetBit: Self = Self(6);
1537 #[doc(alias = "kUSBInformationDeviceOvercurrentBit")]
1538 pub const InformationDeviceOvercurrentBit: Self = Self(7);
1539 #[doc(alias = "kUSBInformationDevicePortIsInTestModeBit")]
1540 pub const InformationDevicePortIsInTestModeBit: Self = Self(8);
1541 #[doc(alias = "kUSBInformationDeviceIsRootHub")]
1542 pub const InformationDeviceIsRootHub: Self = Self(9);
1543 #[doc(alias = "kUSBInformationRootHubisBuiltIn")]
1544 pub const InformationRootHubisBuiltIn: Self = Self(10);
1545 #[doc(alias = "kUSBInformationRootHubIsBuiltInBit")]
1546 pub const InformationRootHubIsBuiltInBit: Self = Self(10);
1547 #[doc(alias = "kUSBInformationDeviceIsRemote")]
1548 pub const InformationDeviceIsRemote: Self = Self(11);
1549 #[doc(alias = "kUSBInformationDeviceIsAttachedToEnclosure")]
1550 pub const InformationDeviceIsAttachedToEnclosure: Self = Self(12);
1551 #[doc(alias = "kUSBInformationDeviceIsOnThunderboltBit")]
1552 pub const InformationDeviceIsOnThunderboltBit: Self = Self(13);
1553 #[doc(alias = "kUSBInformationDeviceIsCaptiveMask")]
1554 pub const InformationDeviceIsCaptiveMask: Self =
1555 Self(1 << USBDeviceInformationBits::InformationDeviceIsCaptiveBit.0);
1556 #[doc(alias = "kUSBInformationDeviceIsAttachedToRootHubMask")]
1557 pub const InformationDeviceIsAttachedToRootHubMask: Self =
1558 Self(1 << USBDeviceInformationBits::InformationDeviceIsAttachedToRootHubBit.0);
1559 #[doc(alias = "kUSBInformationDeviceIsInternalMask")]
1560 pub const InformationDeviceIsInternalMask: Self =
1561 Self(1 << USBDeviceInformationBits::InformationDeviceIsInternalBit.0);
1562 #[doc(alias = "kUSBInformationDeviceIsConnectedMask")]
1563 pub const InformationDeviceIsConnectedMask: Self =
1564 Self(1 << USBDeviceInformationBits::InformationDeviceIsConnectedBit.0);
1565 #[doc(alias = "kUSBInformationDeviceIsEnabledMask")]
1566 pub const InformationDeviceIsEnabledMask: Self =
1567 Self(1 << USBDeviceInformationBits::InformationDeviceIsEnabledBit.0);
1568 #[doc(alias = "kUSBInformationDeviceIsSuspendedMask")]
1569 pub const InformationDeviceIsSuspendedMask: Self =
1570 Self(1 << USBDeviceInformationBits::InformationDeviceIsSuspendedBit.0);
1571 #[doc(alias = "kUSBInformationDeviceIsInResetMask")]
1572 pub const InformationDeviceIsInResetMask: Self =
1573 Self(1 << USBDeviceInformationBits::InformationDeviceIsInResetBit.0);
1574 #[doc(alias = "kUSBInformationDeviceOvercurrentMask")]
1575 pub const InformationDeviceOvercurrentMask: Self =
1576 Self(1 << USBDeviceInformationBits::InformationDeviceOvercurrentBit.0);
1577 #[doc(alias = "kUSBInformationDevicePortIsInTestModeMask")]
1578 pub const InformationDevicePortIsInTestModeMask: Self =
1579 Self(1 << USBDeviceInformationBits::InformationDevicePortIsInTestModeBit.0);
1580 #[doc(alias = "kUSBInformationDeviceIsRootHubMask")]
1581 pub const InformationDeviceIsRootHubMask: Self =
1582 Self(1 << USBDeviceInformationBits::InformationDeviceIsRootHub.0);
1583 #[doc(alias = "kUSBInformationRootHubisBuiltInMask")]
1584 pub const InformationRootHubisBuiltInMask: Self =
1585 Self(1 << USBDeviceInformationBits::InformationRootHubisBuiltIn.0);
1586 #[doc(alias = "kUSBInformationRootHubIsBuiltInMask")]
1587 pub const InformationRootHubIsBuiltInMask: Self =
1588 Self(1 << USBDeviceInformationBits::InformationRootHubIsBuiltInBit.0);
1589 #[doc(alias = "kUSBInformationDeviceIsRemoteMask")]
1590 pub const InformationDeviceIsRemoteMask: Self =
1591 Self(1 << USBDeviceInformationBits::InformationDeviceIsRemote.0);
1592 #[doc(alias = "kUSBInformationDeviceIsAttachedToEnclosureMask")]
1593 pub const InformationDeviceIsAttachedToEnclosureMask: Self =
1594 Self(1 << USBDeviceInformationBits::InformationDeviceIsAttachedToEnclosure.0);
1595 #[doc(alias = "kUSBInformationDeviceIsOnThunderboltMask")]
1596 pub const InformationDeviceIsOnThunderboltMask: Self =
1597 Self(1 << USBDeviceInformationBits::InformationDeviceIsOnThunderboltBit.0);
1598}
1599
1600#[cfg(feature = "objc2")]
1601unsafe impl Encode for USBDeviceInformationBits {
1602 const ENCODING: Encoding = c_uint::ENCODING;
1603}
1604
1605#[cfg(feature = "objc2")]
1606unsafe impl RefEncode for USBDeviceInformationBits {
1607 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1608}
1609
1610#[repr(transparent)]
1614#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1615pub struct USBPowerRequestTypes(pub c_uint);
1616impl USBPowerRequestTypes {
1617 #[doc(alias = "kUSBPowerDuringSleep")]
1618 pub const DuringSleep: Self = Self(0);
1619 #[doc(alias = "kUSBPowerDuringWake")]
1620 pub const DuringWake: Self = Self(1);
1621 #[doc(alias = "kUSBPowerRequestWakeRelease")]
1622 pub const RequestWakeRelease: Self = Self(2);
1623 #[doc(alias = "kUSBPowerRequestSleepRelease")]
1624 pub const RequestSleepRelease: Self = Self(3);
1625 #[doc(alias = "kUSBPowerRequestWakeReallocate")]
1626 pub const RequestWakeReallocate: Self = Self(4);
1627 #[doc(alias = "kUSBPowerRequestSleepReallocate")]
1628 pub const RequestSleepReallocate: Self = Self(5);
1629 #[doc(alias = "kUSBPowerDuringWakeRevocable")]
1630 pub const DuringWakeRevocable: Self = Self(6);
1631 #[doc(alias = "kUSBPowerDuringWakeUSB3")]
1632 pub const DuringWakeUSB3: Self = Self(7);
1633}
1634
1635#[cfg(feature = "objc2")]
1636unsafe impl Encode for USBPowerRequestTypes {
1637 const ENCODING: Encoding = c_uint::ENCODING;
1638}
1639
1640#[cfg(feature = "objc2")]
1641unsafe impl RefEncode for USBPowerRequestTypes {
1642 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1643}
1644
1645pub const kUSBNotificationPreForcedSuspendBit: c_uint = 0;
1647pub const kUSBNotificationPostForcedSuspendBit: c_uint = 1;
1649pub const kUSBNotificationPreForcedResumeBit: c_uint = 2;
1651pub const kUSBNotificationPostForcedResumeBit: c_uint = 3;
1653
1654#[repr(transparent)]
1658#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1659pub struct USBNotificationTypes(pub c_uint);
1660impl USBNotificationTypes {
1661 #[doc(alias = "kUSBNotificationPreForcedSuspend")]
1662 pub const PreForcedSuspend: Self = Self(1 << kUSBNotificationPreForcedSuspendBit);
1663 #[doc(alias = "kUSBNotificationPostForcedSuspend")]
1664 pub const PostForcedSuspend: Self = Self(1 << kUSBNotificationPostForcedSuspendBit);
1665 #[doc(alias = "kUSBNotificationPreForcedResume")]
1666 pub const PreForcedResume: Self = Self(1 << kUSBNotificationPreForcedResumeBit);
1667 #[doc(alias = "kUSBNotificationPostForcedResume")]
1668 pub const PostForcedResume: Self = Self(1 << kUSBNotificationPostForcedResumeBit);
1669}
1670
1671#[cfg(feature = "objc2")]
1672unsafe impl Encode for USBNotificationTypes {
1673 const ENCODING: Encoding = c_uint::ENCODING;
1674}
1675
1676#[cfg(feature = "objc2")]
1677unsafe impl RefEncode for USBNotificationTypes {
1678 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1679}
1680
1681#[repr(transparent)]
1683#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1684pub struct kUSBConnectable(pub c_uint);
1685impl kUSBConnectable {
1686 #[doc(alias = "kUSBPortNotConnectable")]
1687 pub const USBPortNotConnectable: Self = Self(0);
1688 #[doc(alias = "kUSBPortConnectable")]
1689 pub const USBPortConnectable: Self = Self(1);
1690}
1691
1692#[cfg(feature = "objc2")]
1693unsafe impl Encode for kUSBConnectable {
1694 const ENCODING: Encoding = c_uint::ENCODING;
1695}
1696
1697#[cfg(feature = "objc2")]
1698unsafe impl RefEncode for kUSBConnectable {
1699 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1700}
1701
1702#[repr(transparent)]
1704#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1705pub struct kUSBHostConnectorType(pub c_uint);
1706impl kUSBHostConnectorType {
1707 #[doc(alias = "kUSBTypeAConnector")]
1708 pub const USBTypeAConnector: Self = Self(0x00);
1709 #[doc(alias = "kUSBTypeMiniABConnector")]
1710 pub const USBTypeMiniABConnector: Self = Self(0x01);
1711 #[doc(alias = "kUSBTypeExpressCard")]
1712 pub const USBTypeExpressCard: Self = Self(0x02);
1713 #[doc(alias = "kUSB3TypeStdAConnector")]
1714 pub const USB3TypeStdAConnector: Self = Self(0x03);
1715 #[doc(alias = "kUSB3TypeStdBConnector")]
1716 pub const USB3TypeStdBConnector: Self = Self(0x04);
1717 #[doc(alias = "kUSB3TypeMicroBConnector")]
1718 pub const USB3TypeMicroBConnector: Self = Self(0x05);
1719 #[doc(alias = "kUSB3TypeMicroABConnector")]
1720 pub const USB3TypeMicroABConnector: Self = Self(0x06);
1721 #[doc(alias = "kUSB3TypePowerBConnector")]
1722 pub const USB3TypePowerBConnector: Self = Self(0x07);
1723 #[doc(alias = "kUSBProprietaryConnector")]
1724 pub const USBProprietaryConnector: Self = Self(0xFF);
1725}
1726
1727#[cfg(feature = "objc2")]
1728unsafe impl Encode for kUSBHostConnectorType {
1729 const ENCODING: Encoding = c_uint::ENCODING;
1730}
1731
1732#[cfg(feature = "objc2")]
1733unsafe impl RefEncode for kUSBHostConnectorType {
1734 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1735}
1736
1737pub const kUSBSpeed_Mask: c_uint = USBBitRange!(0, 1);
1739pub const kUSBSpeed_Shift: c_uint = USBBitRangePhase!(0, 1);
1741pub const kUSBAddress_Mask: c_uint = USBBitRange!(8, 15);
1743pub const kUSBAddress_Shift: c_uint = USBBitRangePhase!(8, 15);
1745
1746pub const kXHCISSRootHubAddress: c_long = kUSBMaxDevices;
1748pub const kXHCIUSB2RootHubAddress: c_long = kUSBMaxDevices + 1;
1750pub const kSuperSpeedBusBitMask: c_long = 0x01000000;