1use core::ffi::*;
4#[cfg(feature = "objc2")]
5use objc2::__framework_prelude::*;
6
7use crate::*;
8
9pub const kIOUSB20BitrateLow: c_uint = 1500 * 1000;
11pub const kIOUSB20BitrateFull: c_uint = 12 * 1000 * 1000;
13pub const kIOUSB20BitrateHigh: c_uint = 480 * 1000 * 1000;
15pub const kIOUSBAppleVendorID: c_uint = 0x05AC;
17
18#[repr(transparent)]
22#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
23pub struct tIOUSBDescriptorType(pub c_uint);
24impl tIOUSBDescriptorType {
25 #[doc(alias = "kIOUSBDescriptorTypeDevice")]
26 pub const IOUSBDescriptorTypeDevice: Self = Self(1);
27 #[doc(alias = "kIOUSBDescriptorTypeConfiguration")]
28 pub const IOUSBDescriptorTypeConfiguration: Self = Self(2);
29 #[doc(alias = "kIOUSBDescriptorTypeString")]
30 pub const IOUSBDescriptorTypeString: Self = Self(3);
31 #[doc(alias = "kIOUSBDescriptorTypeInterface")]
32 pub const IOUSBDescriptorTypeInterface: Self = Self(4);
33 #[doc(alias = "kIOUSBDescriptorTypeEndpoint")]
34 pub const IOUSBDescriptorTypeEndpoint: Self = Self(5);
35 #[doc(alias = "kIOUSBDescriptorTypeDeviceQualifier")]
36 pub const IOUSBDescriptorTypeDeviceQualifier: Self = Self(6);
37 #[doc(alias = "kIOUSBDescriptorTypeOtherSpeedConfiguration")]
38 pub const IOUSBDescriptorTypeOtherSpeedConfiguration: Self = Self(7);
39 #[doc(alias = "kIOUSBDescriptorTypeInterfacePower")]
40 pub const IOUSBDescriptorTypeInterfacePower: Self = Self(8);
41 #[doc(alias = "kIOUSBDescriptorTypeOTG")]
42 pub const IOUSBDescriptorTypeOTG: Self = Self(9);
43 #[doc(alias = "kIOUSBDescriptorTypeDebug")]
44 pub const IOUSBDescriptorTypeDebug: Self = Self(10);
45 #[doc(alias = "kIOUSBDescriptorTypeInterfaceAssociation")]
46 pub const IOUSBDescriptorTypeInterfaceAssociation: Self = Self(11);
47 #[doc(alias = "kIOUSBDescriptorTypeBOS")]
48 pub const IOUSBDescriptorTypeBOS: Self = Self(15);
49 #[doc(alias = "kIOUSBDescriptorTypeDeviceCapability")]
50 pub const IOUSBDescriptorTypeDeviceCapability: Self = Self(16);
51 #[doc(alias = "kIOUSBDecriptorTypeHID")]
52 pub const IOUSBDecriptorTypeHID: Self = Self(33);
53 #[doc(alias = "kIOUSBDecriptorTypeReport")]
54 pub const IOUSBDecriptorTypeReport: Self = Self(34);
55 #[doc(alias = "kIOUSBDescriptorTypePhysical")]
56 pub const IOUSBDescriptorTypePhysical: Self = Self(35);
57 #[doc(alias = "kIOUSBDescriptorTypeHub")]
58 pub const IOUSBDescriptorTypeHub: Self = Self(41);
59 #[doc(alias = "kIOUSBDescriptorTypeSuperSpeedHub")]
60 pub const IOUSBDescriptorTypeSuperSpeedHub: Self = Self(42);
61 #[doc(alias = "kIOUSBDescriptorTypeSuperSpeedUSBEndpointCompanion")]
62 pub const IOUSBDescriptorTypeSuperSpeedUSBEndpointCompanion: Self = Self(48);
63 #[doc(alias = "kIOUSBDescriptorTypeSuperSpeedPlusIsochronousEndpointCompanion")]
64 pub const IOUSBDescriptorTypeSuperSpeedPlusIsochronousEndpointCompanion: Self = Self(49);
65}
66
67#[cfg(feature = "objc2")]
68unsafe impl Encode for tIOUSBDescriptorType {
69 const ENCODING: Encoding = c_uint::ENCODING;
70}
71
72#[cfg(feature = "objc2")]
73unsafe impl RefEncode for tIOUSBDescriptorType {
74 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
75}
76
77#[repr(transparent)]
81#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
82pub struct tIOUSBDescriptorSize(pub c_uint);
83impl tIOUSBDescriptorSize {
84 #[doc(alias = "kIOUSBDescriptorHeaderSize")]
85 pub const IOUSBDescriptorHeaderSize: Self = Self(2);
86 #[doc(alias = "kIOUSBDescriptorSizeDevice")]
87 pub const IOUSBDescriptorSizeDevice: Self = Self(18);
88 #[doc(alias = "kIOUSBDescriptorSizeConfiguration")]
89 pub const IOUSBDescriptorSizeConfiguration: Self = Self(9);
90 #[doc(alias = "kIOUSBDescriptorSizeInterface")]
91 pub const IOUSBDescriptorSizeInterface: Self = Self(9);
92 #[doc(alias = "kIOUSBDescriptorSizeEndpoint")]
93 pub const IOUSBDescriptorSizeEndpoint: Self = Self(7);
94 #[doc(alias = "kIOUSBDescriptorSizeStringMinimum")]
95 pub const IOUSBDescriptorSizeStringMinimum: Self =
96 Self(tIOUSBDescriptorSize::IOUSBDescriptorHeaderSize.0);
97 #[doc(alias = "kIOUSBDescriptorSizeStringMaximum")]
98 pub const IOUSBDescriptorSizeStringMaximum: Self = Self(255);
99 #[doc(alias = "kIOUSBDescriptorSizeDeviceQualifier")]
100 pub const IOUSBDescriptorSizeDeviceQualifier: Self = Self(10);
101 #[doc(alias = "kIOUSBDescriptorSizeInterfaceAssociation")]
102 pub const IOUSBDescriptorSizeInterfaceAssociation: Self = Self(8);
103 #[doc(alias = "kIOUSBDescriptorSizeBOS")]
104 pub const IOUSBDescriptorSizeBOS: Self = Self(5);
105 #[doc(alias = "kIOUSBDescriptorSizeDeviceCapability")]
106 pub const IOUSBDescriptorSizeDeviceCapability: Self = Self(3);
107 #[doc(alias = "kIOUSBDescriptorSizeUSB20ExtensionCapability")]
108 pub const IOUSBDescriptorSizeUSB20ExtensionCapability: Self = Self(7);
109 #[doc(alias = "kIOUSBDescriptorSizeSuperSpeedUSBDeviceCapability")]
110 pub const IOUSBDescriptorSizeSuperSpeedUSBDeviceCapability: Self = Self(10);
111 #[doc(alias = "kIOUSBDescriptorSizeContainerIDCapability")]
112 pub const IOUSBDescriptorSizeContainerIDCapability: Self = Self(20);
113 #[doc(alias = "kIOUSBDescriptorSizeHubMinimum")]
114 pub const IOUSBDescriptorSizeHubMinimum: Self = Self(9);
115 #[doc(alias = "kIOUSBDescriptorSizeHubMaximum")]
116 pub const IOUSBDescriptorSizeHubMaximum: Self = Self(21);
117 #[doc(alias = "kIOUSBDescriptorSizeSuperSpeedHub")]
118 pub const IOUSBDescriptorSizeSuperSpeedHub: Self = Self(12);
119 #[doc(alias = "kIOUSBDescriptorSizeSuperSpeedUSBEndpointCompanion")]
120 pub const IOUSBDescriptorSizeSuperSpeedUSBEndpointCompanion: Self = Self(6);
121 #[doc(alias = "kIOUSBDescriptorSizeSuperSpeedPlusIsochronousEndpointCompanion")]
122 pub const IOUSBDescriptorSizeSuperSpeedPlusIsochronousEndpointCompanion: Self = Self(8);
123 #[doc(alias = "kIOUSBDescriptorSizeBillboardDeviceMinimum")]
124 pub const IOUSBDescriptorSizeBillboardDeviceMinimum: Self = Self(44);
125 #[doc(alias = "kIOUSBDescriptorSizeBillboardDeviceMaximum")]
126 pub const IOUSBDescriptorSizeBillboardDeviceMaximum: Self = Self(256);
127 #[doc(alias = "kIOUSBDescriptorSizePlatformECIDCapability")]
128 pub const IOUSBDescriptorSizePlatformECIDCapability: Self = Self(28);
129 #[doc(alias = "kIOUSBDescriptorSizePlatformCapability")]
130 pub const IOUSBDescriptorSizePlatformCapability: Self = Self(20);
131}
132
133#[cfg(feature = "objc2")]
134unsafe impl Encode for tIOUSBDescriptorSize {
135 const ENCODING: Encoding = c_uint::ENCODING;
136}
137
138#[cfg(feature = "objc2")]
139unsafe impl RefEncode for tIOUSBDescriptorSize {
140 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
141}
142
143#[repr(C)]
150#[derive(Clone, Copy, Debug, PartialEq)]
151pub struct IOUSBDescriptorHeader {
152 pub bLength: u8,
153 pub bDescriptorType: u8,
154}
155
156#[cfg(feature = "objc2")]
157unsafe impl Encode for IOUSBDescriptorHeader {
158 const ENCODING: Encoding =
159 Encoding::Struct("IOUSBDescriptorHeader", &[<u8>::ENCODING, <u8>::ENCODING]);
160}
161
162#[cfg(feature = "objc2")]
163unsafe impl RefEncode for IOUSBDescriptorHeader {
164 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
165}
166
167pub type IOUSBDescriptor = IOUSBDescriptorHeader;
173
174#[repr(C, packed)]
183#[derive(Clone, Copy, Debug, PartialEq)]
184pub struct IOUSBDeviceDescriptor {
185 pub bLength: u8,
186 pub bDescriptorType: u8,
187 pub bcdUSB: u16,
188 pub bDeviceClass: u8,
189 pub bDeviceSubClass: u8,
190 pub bDeviceProtocol: u8,
191 pub bMaxPacketSize0: u8,
192 pub idVendor: u16,
193 pub idProduct: u16,
194 pub bcdDevice: u16,
195 pub iManufacturer: u8,
196 pub iProduct: u8,
197 pub iSerialNumber: u8,
198 pub bNumConfigurations: u8,
199}
200
201#[cfg(feature = "objc2")]
202unsafe impl Encode for IOUSBDeviceDescriptor {
203 const ENCODING: Encoding = Encoding::Struct(
204 "IOUSBDeviceDescriptor",
205 &[
206 <u8>::ENCODING,
207 <u8>::ENCODING,
208 <u16>::ENCODING,
209 <u8>::ENCODING,
210 <u8>::ENCODING,
211 <u8>::ENCODING,
212 <u8>::ENCODING,
213 <u16>::ENCODING,
214 <u16>::ENCODING,
215 <u16>::ENCODING,
216 <u8>::ENCODING,
217 <u8>::ENCODING,
218 <u8>::ENCODING,
219 <u8>::ENCODING,
220 ],
221 );
222}
223
224#[cfg(feature = "objc2")]
225unsafe impl RefEncode for IOUSBDeviceDescriptor {
226 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
227}
228
229#[repr(C, packed)]
239#[derive(Clone, Copy, Debug, PartialEq)]
240pub struct IOUSBDeviceQualifierDescriptor {
241 pub bLength: u8,
242 pub bDescriptorType: u8,
243 pub bcdUSB: u16,
244 pub bDeviceClass: u8,
245 pub bDeviceSubClass: u8,
246 pub bDeviceProtocol: u8,
247 pub bMaxPacketSize0: u8,
248 pub bNumConfigurations: u8,
249 pub bReserved: u8,
250}
251
252#[cfg(feature = "objc2")]
253unsafe impl Encode for IOUSBDeviceQualifierDescriptor {
254 const ENCODING: Encoding = Encoding::Struct(
255 "IOUSBDeviceQualifierDescriptor",
256 &[
257 <u8>::ENCODING,
258 <u8>::ENCODING,
259 <u16>::ENCODING,
260 <u8>::ENCODING,
261 <u8>::ENCODING,
262 <u8>::ENCODING,
263 <u8>::ENCODING,
264 <u8>::ENCODING,
265 <u8>::ENCODING,
266 ],
267 );
268}
269
270#[cfg(feature = "objc2")]
271unsafe impl RefEncode for IOUSBDeviceQualifierDescriptor {
272 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
273}
274
275#[repr(C, packed)]
280#[derive(Clone, Copy, Debug, PartialEq)]
281pub struct IOUSBConfigurationDescHeader {
282 pub bLength: u8,
283 pub bDescriptorType: u8,
284 pub wTotalLength: u16,
285}
286
287#[cfg(feature = "objc2")]
288unsafe impl Encode for IOUSBConfigurationDescHeader {
289 const ENCODING: Encoding = Encoding::Struct(
290 "IOUSBConfigurationDescHeader",
291 &[<u8>::ENCODING, <u8>::ENCODING, <u16>::ENCODING],
292 );
293}
294
295#[cfg(feature = "objc2")]
296unsafe impl RefEncode for IOUSBConfigurationDescHeader {
297 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
298}
299
300#[repr(C, packed)]
311#[derive(Clone, Copy, Debug, PartialEq)]
312pub struct IOUSBConfigurationDescriptor {
313 pub bLength: u8,
314 pub bDescriptorType: u8,
315 pub wTotalLength: u16,
316 pub bNumInterfaces: u8,
317 pub bConfigurationValue: u8,
318 pub iConfiguration: u8,
319 pub bmAttributes: u8,
320 pub MaxPower: u8,
321}
322
323#[cfg(feature = "objc2")]
324unsafe impl Encode for IOUSBConfigurationDescriptor {
325 const ENCODING: Encoding = Encoding::Struct(
326 "IOUSBConfigurationDescriptor",
327 &[
328 <u8>::ENCODING,
329 <u8>::ENCODING,
330 <u16>::ENCODING,
331 <u8>::ENCODING,
332 <u8>::ENCODING,
333 <u8>::ENCODING,
334 <u8>::ENCODING,
335 <u8>::ENCODING,
336 ],
337 );
338}
339
340#[cfg(feature = "objc2")]
341unsafe impl RefEncode for IOUSBConfigurationDescriptor {
342 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
343}
344
345pub const kIOUSBConfigurationDescriptorAttributeRemoteWakeCapable: c_uint = IOUSBBit!(5);
347pub const kIOUSBConfigurationDescriptorAttributeSelfPowered: c_uint = IOUSBBit!(6);
349
350#[repr(C)]
359#[derive(Clone, Copy, Debug, PartialEq)]
360pub struct IOUSBInterfaceDescriptor {
361 pub bLength: u8,
362 pub bDescriptorType: u8,
363 pub bInterfaceNumber: u8,
364 pub bAlternateSetting: u8,
365 pub bNumEndpoints: u8,
366 pub bInterfaceClass: u8,
367 pub bInterfaceSubClass: u8,
368 pub bInterfaceProtocol: u8,
369 pub iInterface: u8,
370}
371
372#[cfg(feature = "objc2")]
373unsafe impl Encode for IOUSBInterfaceDescriptor {
374 const ENCODING: Encoding = Encoding::Struct(
375 "IOUSBInterfaceDescriptor",
376 &[
377 <u8>::ENCODING,
378 <u8>::ENCODING,
379 <u8>::ENCODING,
380 <u8>::ENCODING,
381 <u8>::ENCODING,
382 <u8>::ENCODING,
383 <u8>::ENCODING,
384 <u8>::ENCODING,
385 <u8>::ENCODING,
386 ],
387 );
388}
389
390#[cfg(feature = "objc2")]
391unsafe impl RefEncode for IOUSBInterfaceDescriptor {
392 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
393}
394
395#[repr(C, packed)]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub struct IOUSBEndpointDescriptor {
406 pub bLength: u8,
407 pub bDescriptorType: u8,
408 pub bEndpointAddress: u8,
409 pub bmAttributes: u8,
410 pub wMaxPacketSize: u16,
411 pub bInterval: u8,
412}
413
414#[cfg(feature = "objc2")]
415unsafe impl Encode for IOUSBEndpointDescriptor {
416 const ENCODING: Encoding = Encoding::Struct(
417 "IOUSBEndpointDescriptor",
418 &[
419 <u8>::ENCODING,
420 <u8>::ENCODING,
421 <u8>::ENCODING,
422 <u8>::ENCODING,
423 <u16>::ENCODING,
424 <u8>::ENCODING,
425 ],
426 );
427}
428
429#[cfg(feature = "objc2")]
430unsafe impl RefEncode for IOUSBEndpointDescriptor {
431 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
432}
433
434pub const kIOUSBEndpointDescriptorNumber: c_uint = IOUSBBitRange!(0, 3);
436pub const kIOUSBEndpointDescriptorNumberPhase: c_uint = IOUSBBitRangePhase!(0, 3);
438pub const kIOUSBEndpointDescriptorEndpointAddressReserved: c_uint = IOUSBBitRange!(4, 6);
440pub const kIOUSBEndpointDescriptorDirection: c_uint = IOUSBBit!(7);
442pub const kIOUSBEndpointDescriptorDirectionPhase: c_uint = IOUSBBitRangePhase!(7, 7);
444pub const kIOUSBEndpointDescriptorDirectionOut: c_uint = 0;
446pub const kIOUSBEndpointDescriptorDirectionIn: c_uint = IOUSBBit!(7);
448pub const kIOUSBEndpointDescriptorTransferType: c_uint = IOUSBBitRange!(0, 1);
450pub const kIOUSBEndpointDescriptorTransferTypePhase: c_uint = IOUSBBitRangePhase!(0, 1);
452pub const kIOUSBEndpointDescriptorTransferTypeControl: c_uint = 0 << IOUSBBitRangePhase!(0, 1);
454pub const kIOUSBEndpointDescriptorTransferTypeIsochronous: c_uint = 1 << IOUSBBitRangePhase!(0, 1);
456pub const kIOUSBEndpointDescriptorTransferTypeBulk: c_uint = 2 << IOUSBBitRangePhase!(0, 1);
458pub const kIOUSBEndpointDescriptorTransferTypeInterrupt: c_uint = 3 << IOUSBBitRangePhase!(0, 1);
460pub const kIOUSBEndpointDescriptorSynchronizationType: c_uint = IOUSBBitRange!(2, 3);
462pub const kIOUSBEndpointDescriptorSynchronizationTypePhase: c_uint = IOUSBBitRangePhase!(2, 3);
464pub const kIOUSBEndpointDescriptorSynchronizationTypeNone: c_uint = 0 << IOUSBBitRangePhase!(2, 3);
466pub const kIOUSBEndpointDescriptorSynchronizationTypeAsynchronous: c_uint =
468 1 << IOUSBBitRangePhase!(2, 3);
469pub const kIOUSBEndpointDescriptorSynchronizationTypeAdaptive: c_uint =
471 2 << IOUSBBitRangePhase!(2, 3);
472pub const kIOUSBEndpointDescriptorSynchronizationTypeSynchronous: c_uint =
474 3 << IOUSBBitRangePhase!(2, 3);
475pub const kIOUSBEndpointDescriptorUsageType: c_uint = IOUSBBitRange!(4, 5);
477pub const kIOUSBEndpointDescriptorUsageTypePhase: c_uint = IOUSBBitRangePhase!(4, 5);
479pub const kIOUSBEndpointDescriptorUsageTypeInterruptPeriodic: c_uint =
481 0 << IOUSBBitRangePhase!(4, 5);
482pub const kIOUSBEndpointDescriptorUsageTypeInterruptNotification: c_uint =
484 1 << IOUSBBitRangePhase!(4, 5);
485pub const kIOUSBEndpointDescriptorUsageTypeInterruptReserved1: c_uint =
487 2 << IOUSBBitRangePhase!(4, 5);
488pub const kIOUSBEndpointDescriptorUsageTypeInterruptReserved2: c_uint =
490 3 << IOUSBBitRangePhase!(4, 5);
491pub const kIOUSBEndpointDescriptorUsageTypeIsocData: c_uint = 0 << IOUSBBitRangePhase!(4, 5);
493pub const kIOUSBEndpointDescriptorUsageTypeIsocFeedback: c_uint = 1 << IOUSBBitRangePhase!(4, 5);
495pub const kIOUSBEndpointDescriptorUsageTypeIsocImplicit: c_uint = 2 << IOUSBBitRangePhase!(4, 5);
497pub const kIOUSBEndpointDescriptorUsageTypeIsocReserved: c_uint = 3 << IOUSBBitRangePhase!(4, 5);
499pub const kIOUSBEndpointDescriptorPacketSize: c_uint = IOUSBBitRange!(0, 10);
501pub const kIOUSBEndpointDescriptorPacketSizePhase: c_uint = IOUSBBitRangePhase!(0, 10);
503pub const kIOUSBEndpointDescriptorPacketSizeMult: c_uint = IOUSBBitRange!(11, 12);
505pub const kIOUSBEndpointDescriptorPacketSizeMultPhase: c_uint = IOUSBBitRangePhase!(11, 12);
507pub const kIOUSBEndpointDescriptorReserved: c_uint = IOUSBBitRange!(13, 15);
509pub const kIOUSBEndpointDescriptorReservedPhase: c_uint = IOUSBBitRangePhase!(13, 15);
511
512#[repr(transparent)]
516#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
517pub struct tIOUSBEndpointDirection(pub c_uint);
518impl tIOUSBEndpointDirection {
519 #[doc(alias = "kIOUSBEndpointDirectionOut")]
520 pub const IOUSBEndpointDirectionOut: Self =
521 Self(kIOUSBEndpointDescriptorDirectionOut >> kIOUSBEndpointDescriptorDirectionPhase);
522 #[doc(alias = "kIOUSBEndpointDirectionIn")]
523 pub const IOUSBEndpointDirectionIn: Self =
524 Self(kIOUSBEndpointDescriptorDirectionIn >> kIOUSBEndpointDescriptorDirectionPhase);
525 #[doc(alias = "kIOUSBEndpointDirectionUnknown")]
526 pub const IOUSBEndpointDirectionUnknown: Self = Self(2);
527}
528
529#[cfg(feature = "objc2")]
530unsafe impl Encode for tIOUSBEndpointDirection {
531 const ENCODING: Encoding = c_uint::ENCODING;
532}
533
534#[cfg(feature = "objc2")]
535unsafe impl RefEncode for tIOUSBEndpointDirection {
536 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
537}
538
539#[repr(transparent)]
543#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
544pub struct tIOUSBEndpointType(pub c_uint);
545impl tIOUSBEndpointType {
546 #[doc(alias = "kIOUSBEndpointTypeControl")]
547 pub const IOUSBEndpointTypeControl: Self = Self(
548 kIOUSBEndpointDescriptorTransferTypeControl >> kIOUSBEndpointDescriptorTransferTypePhase,
549 );
550 #[doc(alias = "kIOUSBEndpointTypeIsochronous")]
551 pub const IOUSBEndpointTypeIsochronous: Self = Self(
552 kIOUSBEndpointDescriptorTransferTypeIsochronous
553 >> kIOUSBEndpointDescriptorTransferTypePhase,
554 );
555 #[doc(alias = "kIOUSBEndpointTypeBulk")]
556 pub const IOUSBEndpointTypeBulk: Self =
557 Self(kIOUSBEndpointDescriptorTransferTypeBulk >> kIOUSBEndpointDescriptorTransferTypePhase);
558 #[doc(alias = "kIOUSBEndpointTypeInterrupt")]
559 pub const IOUSBEndpointTypeInterrupt: Self = Self(
560 kIOUSBEndpointDescriptorTransferTypeInterrupt >> kIOUSBEndpointDescriptorTransferTypePhase,
561 );
562}
563
564#[cfg(feature = "objc2")]
565unsafe impl Encode for tIOUSBEndpointType {
566 const ENCODING: Encoding = c_uint::ENCODING;
567}
568
569#[cfg(feature = "objc2")]
570unsafe impl RefEncode for tIOUSBEndpointType {
571 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
572}
573
574#[repr(transparent)]
576#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
577pub struct tIOUSBEndpointSynchronizationType(pub c_uint);
578impl tIOUSBEndpointSynchronizationType {
579 #[doc(alias = "kIOUSBEndpointSynchronizationTypeNone")]
580 pub const IOUSBEndpointSynchronizationTypeNone: Self = Self(
581 kIOUSBEndpointDescriptorSynchronizationTypeNone
582 >> kIOUSBEndpointDescriptorSynchronizationTypePhase,
583 );
584 #[doc(alias = "kIOUSBEndpointSynchronizationTypeAsynchronous")]
585 pub const IOUSBEndpointSynchronizationTypeAsynchronous: Self = Self(
586 kIOUSBEndpointDescriptorSynchronizationTypeAsynchronous
587 >> kIOUSBEndpointDescriptorSynchronizationTypePhase,
588 );
589 #[doc(alias = "kIOUSBEndpointSynchronizationTypeAdaptive")]
590 pub const IOUSBEndpointSynchronizationTypeAdaptive: Self = Self(
591 kIOUSBEndpointDescriptorSynchronizationTypeAdaptive
592 >> kIOUSBEndpointDescriptorSynchronizationTypePhase,
593 );
594 #[doc(alias = "kIOUSBEndpointSynchronizationTypeSynchronous")]
595 pub const IOUSBEndpointSynchronizationTypeSynchronous: Self = Self(
596 kIOUSBEndpointDescriptorSynchronizationTypeSynchronous
597 >> kIOUSBEndpointDescriptorSynchronizationTypePhase,
598 );
599}
600
601#[cfg(feature = "objc2")]
602unsafe impl Encode for tIOUSBEndpointSynchronizationType {
603 const ENCODING: Encoding = c_uint::ENCODING;
604}
605
606#[cfg(feature = "objc2")]
607unsafe impl RefEncode for tIOUSBEndpointSynchronizationType {
608 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
609}
610
611#[repr(transparent)]
613#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
614pub struct tIOUSBEndpointUsageType(pub c_uint);
615impl tIOUSBEndpointUsageType {
616 #[doc(alias = "kIOUSBEndpointUsageTypeIsocData")]
617 pub const IOUSBEndpointUsageTypeIsocData: Self =
618 Self(kIOUSBEndpointDescriptorUsageTypeIsocData >> kIOUSBEndpointDescriptorUsageTypePhase);
619 #[doc(alias = "kIOUSBEndpointUsageTypeIsocFeedback")]
620 pub const IOUSBEndpointUsageTypeIsocFeedback: Self = Self(
621 kIOUSBEndpointDescriptorUsageTypeIsocFeedback >> kIOUSBEndpointDescriptorUsageTypePhase,
622 );
623 #[doc(alias = "kIOUSBEndpointUsageTypeIsocImplicit")]
624 pub const IOUSBEndpointUsageTypeIsocImplicit: Self = Self(
625 kIOUSBEndpointDescriptorUsageTypeIsocImplicit >> kIOUSBEndpointDescriptorUsageTypePhase,
626 );
627}
628
629#[cfg(feature = "objc2")]
630unsafe impl Encode for tIOUSBEndpointUsageType {
631 const ENCODING: Encoding = c_uint::ENCODING;
632}
633
634#[cfg(feature = "objc2")]
635unsafe impl RefEncode for tIOUSBEndpointUsageType {
636 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
637}
638
639#[repr(transparent)]
643#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
644pub struct tIOUSBLanguageID(pub c_uint);
645impl tIOUSBLanguageID {
646 #[doc(alias = "kIOUSBLanguageIDEnglishUS")]
647 pub const IOUSBLanguageIDEnglishUS: Self = Self(0x0409);
648}
649
650#[cfg(feature = "objc2")]
651unsafe impl Encode for tIOUSBLanguageID {
652 const ENCODING: Encoding = c_uint::ENCODING;
653}
654
655#[cfg(feature = "objc2")]
656unsafe impl RefEncode for tIOUSBLanguageID {
657 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
658}
659
660#[repr(C)]
669#[derive(Clone, Copy, Debug, PartialEq)]
670pub struct IOUSBStringDescriptor {
671 pub bLength: u8,
672 pub bDescriptorType: u8,
673 pub bString: [u8; 1],
674}
675
676#[cfg(feature = "objc2")]
677unsafe impl Encode for IOUSBStringDescriptor {
678 const ENCODING: Encoding = Encoding::Struct(
679 "IOUSBStringDescriptor",
680 &[<u8>::ENCODING, <u8>::ENCODING, <[u8; 1]>::ENCODING],
681 );
682}
683
684#[cfg(feature = "objc2")]
685unsafe impl RefEncode for IOUSBStringDescriptor {
686 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
687}
688
689#[repr(transparent)]
691#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
692pub struct tIOUSBDeviceCapabilityType(pub c_uint);
693impl tIOUSBDeviceCapabilityType {
694 #[doc(alias = "kIOUSBDeviceCapabilityTypeWireless")]
695 pub const IOUSBDeviceCapabilityTypeWireless: Self = Self(1);
696 #[doc(alias = "kIOUSBDeviceCapabilityTypeUSB20Extension")]
697 pub const IOUSBDeviceCapabilityTypeUSB20Extension: Self = Self(2);
698 #[doc(alias = "kIOUSBDeviceCapabilityTypeSuperSpeed")]
699 pub const IOUSBDeviceCapabilityTypeSuperSpeed: Self = Self(3);
700 #[doc(alias = "kIOUSBDeviceCapabilityTypeContainerID")]
701 pub const IOUSBDeviceCapabilityTypeContainerID: Self = Self(4);
702 #[doc(alias = "kIOUSBDeviceCapabilityTypePlatform")]
703 pub const IOUSBDeviceCapabilityTypePlatform: Self = Self(5);
704 #[doc(alias = "kIOUSBDeviceCapabilityTypePowerDelivery")]
705 pub const IOUSBDeviceCapabilityTypePowerDelivery: Self = Self(6);
706 #[doc(alias = "kIOUSBDeviceCapabilityTypeBatteryInfo")]
707 pub const IOUSBDeviceCapabilityTypeBatteryInfo: Self = Self(7);
708 #[doc(alias = "kIOUSBDeviceCapabilityTypePdConsumerPort")]
709 pub const IOUSBDeviceCapabilityTypePdConsumerPort: Self = Self(8);
710 #[doc(alias = "kIOUSBDeviceCapabilityTypePdProviderPort")]
711 pub const IOUSBDeviceCapabilityTypePdProviderPort: Self = Self(9);
712 #[doc(alias = "kIOUSBDeviceCapabilityTypeSuperSpeedPlus")]
713 pub const IOUSBDeviceCapabilityTypeSuperSpeedPlus: Self = Self(10);
714 #[doc(alias = "kIOUSBDeviceCapabilityTypePrecisionMeasurement")]
715 pub const IOUSBDeviceCapabilityTypePrecisionMeasurement: Self = Self(11);
716 #[doc(alias = "kIOUSBDeviceCapabilityTypeWirelessExt")]
717 pub const IOUSBDeviceCapabilityTypeWirelessExt: Self = Self(12);
718 #[doc(alias = "kIOUSBDeviceCapabilityTypeBillboard")]
719 pub const IOUSBDeviceCapabilityTypeBillboard: Self = Self(13);
720 #[doc(alias = "kIOUSBDeviceCapabilityTypeBillboardAltMode")]
721 pub const IOUSBDeviceCapabilityTypeBillboardAltMode: Self = Self(15);
722}
723
724#[cfg(feature = "objc2")]
725unsafe impl Encode for tIOUSBDeviceCapabilityType {
726 const ENCODING: Encoding = c_uint::ENCODING;
727}
728
729#[cfg(feature = "objc2")]
730unsafe impl RefEncode for tIOUSBDeviceCapabilityType {
731 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
732}
733
734#[repr(C, packed)]
743#[derive(Clone, Copy, Debug, PartialEq)]
744pub struct IOUSBBOSDescriptor {
745 pub bLength: u8,
746 pub bDescriptorType: u8,
747 pub wTotalLength: u16,
748 pub bNumDeviceCaps: u8,
749}
750
751#[cfg(feature = "objc2")]
752unsafe impl Encode for IOUSBBOSDescriptor {
753 const ENCODING: Encoding = Encoding::Struct(
754 "IOUSBBOSDescriptor",
755 &[
756 <u8>::ENCODING,
757 <u8>::ENCODING,
758 <u16>::ENCODING,
759 <u8>::ENCODING,
760 ],
761 );
762}
763
764#[cfg(feature = "objc2")]
765unsafe impl RefEncode for IOUSBBOSDescriptor {
766 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
767}
768
769#[repr(C)]
778#[derive(Clone, Copy, Debug, PartialEq)]
779pub struct IOUSBDeviceCapabilityDescriptorHeader {
780 pub bLength: u8,
781 pub bDescriptorType: u8,
782 pub bDevCapabilityType: u8,
783}
784
785#[cfg(feature = "objc2")]
786unsafe impl Encode for IOUSBDeviceCapabilityDescriptorHeader {
787 const ENCODING: Encoding = Encoding::Struct(
788 "IOUSBDeviceCapabilityDescriptorHeader",
789 &[<u8>::ENCODING, <u8>::ENCODING, <u8>::ENCODING],
790 );
791}
792
793#[cfg(feature = "objc2")]
794unsafe impl RefEncode for IOUSBDeviceCapabilityDescriptorHeader {
795 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
796}
797
798#[repr(C, packed)]
803#[derive(Clone, Copy, Debug, PartialEq)]
804pub struct IOUSBDeviceCapabilityUSB2Extension {
805 pub bLength: u8,
806 pub bDescriptorType: u8,
807 pub bDevCapabilityType: u8,
808 pub bmAttributes: u32,
809}
810
811#[cfg(feature = "objc2")]
812unsafe impl Encode for IOUSBDeviceCapabilityUSB2Extension {
813 const ENCODING: Encoding = Encoding::Struct(
814 "IOUSBDeviceCapabilityUSB2Extension",
815 &[
816 <u8>::ENCODING,
817 <u8>::ENCODING,
818 <u8>::ENCODING,
819 <u32>::ENCODING,
820 ],
821 );
822}
823
824#[cfg(feature = "objc2")]
825unsafe impl RefEncode for IOUSBDeviceCapabilityUSB2Extension {
826 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
827}
828
829pub const kIOUSBUSB20ExtensionCapabilityLPM: c_uint = IOUSBBit!(1);
831pub const kIOUSBUSB20ExtensionCapabilityBESLSupport: c_uint = IOUSBBit!(2);
833pub const kIOUSBUSB20ExtensionCapabilityBESLValid: c_uint = IOUSBBit!(3);
835pub const kIOUSBUSB20ExtensionCapabilityBESLDValid: c_uint = IOUSBBit!(4);
837pub const kIOUSBUSB20ExtensionCapabilityBESL: c_uint = IOUSBBitRange!(8, 11);
839pub const kIOUSBUSB20ExtensionCapabilityBESLPhase: c_uint = IOUSBBitRangePhase!(8, 11);
841pub const kIOUSBUSB20ExtensionCapabilityBESLD: c_uint = IOUSBBitRange!(12, 15);
843pub const kIOUSBUSB20ExtensionCapabilityBESLDPhase: c_uint = IOUSBBitRangePhase!(12, 15);
845
846#[repr(C, packed)]
850#[derive(Clone, Copy, Debug, PartialEq)]
851pub struct IOUSBDeviceCapabilitySuperSpeedUSB {
852 pub bLength: u8,
853 pub bDescriptorType: u8,
854 pub bDevCapabilityType: u8,
855 pub bmAttributes: u8,
856 pub wSpeedsSupported: u16,
857 pub bFunctionalitySupport: u8,
858 pub bU1DevExitLat: u8,
859 pub wU2DevExitLat: u16,
860}
861
862#[cfg(feature = "objc2")]
863unsafe impl Encode for IOUSBDeviceCapabilitySuperSpeedUSB {
864 const ENCODING: Encoding = Encoding::Struct(
865 "IOUSBDeviceCapabilitySuperSpeedUSB",
866 &[
867 <u8>::ENCODING,
868 <u8>::ENCODING,
869 <u8>::ENCODING,
870 <u8>::ENCODING,
871 <u16>::ENCODING,
872 <u8>::ENCODING,
873 <u8>::ENCODING,
874 <u16>::ENCODING,
875 ],
876 );
877}
878
879#[cfg(feature = "objc2")]
880unsafe impl RefEncode for IOUSBDeviceCapabilitySuperSpeedUSB {
881 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
882}
883
884pub const kIOUSBSuperSpeedDeviceCapabilityLTM: c_uint = IOUSBBit!(1);
886pub const kIOUSBSuperSpeedDeviceCapabilityLowSpeed: c_uint = IOUSBBit!(0);
888pub const kIOUSBSuperSpeedDeviceCapabilityFullSpeed: c_uint = IOUSBBit!(1);
890pub const kIOUSBSuperSpeedDeviceCapabilityHighSpeed: c_uint = IOUSBBit!(2);
892pub const kIOUSBSuperSpeedDeviceCapability5Gb: c_uint = IOUSBBit!(3);
894pub const kIOUSBSuperSpeedDeviceCapabilitySupportLowSpeed: c_uint = 0;
896pub const kIOUSBSuperSpeedDeviceCapabilitySupportFullSpeed: c_uint = 1;
898pub const kIOUSBSuperSpeedDeviceCapabilitySupportHighSpeed: c_uint = 2;
900pub const kIOUSBSuperSpeedDeviceCapabilitySupport5Gb: c_uint = 3;
902pub const kIOUSBSuperSpeedDeviceCapabilityU1DevExitLatMax: c_uint = 0xa;
904pub const kIOUSBSuperSpeedDeviceCapabilityU2DevExitLatMax: c_uint = 0x7ff;
906
907#[repr(C, packed)]
912#[derive(Clone, Copy, Debug, PartialEq)]
913pub struct IOUSBDeviceCapabilitySuperSpeedPlusUSB {
914 pub bLength: u8,
915 pub bDescriptorType: u8,
916 pub bDevCapabilityType: u8,
917 pub bReserved: u8,
918 pub bmAttributes: u32,
919 pub wFunctionalitySupport: u16,
920 pub wReserved: u16,
921 pub bmSublinkSpeedAttr: *mut u32,
922}
923
924#[cfg(feature = "objc2")]
925unsafe impl Encode for IOUSBDeviceCapabilitySuperSpeedPlusUSB {
926 const ENCODING: Encoding = Encoding::Struct(
927 "IOUSBDeviceCapabilitySuperSpeedPlusUSB",
928 &[
929 <u8>::ENCODING,
930 <u8>::ENCODING,
931 <u8>::ENCODING,
932 <u8>::ENCODING,
933 <u32>::ENCODING,
934 <u16>::ENCODING,
935 <u16>::ENCODING,
936 <*mut u32>::ENCODING,
937 ],
938 );
939}
940
941#[cfg(feature = "objc2")]
942unsafe impl RefEncode for IOUSBDeviceCapabilitySuperSpeedPlusUSB {
943 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
944}
945
946pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedAttrCount: c_uint = IOUSBBitRange!(0, 4);
948pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedAttrCountPhase: c_uint =
950 IOUSBBitRangePhase!(0, 4);
951pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedIdCount: c_uint = IOUSBBitRange!(5, 8);
953pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedIdCountPhase: c_uint =
955 IOUSBBitRangePhase!(5, 8);
956pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkMinSpeedId: c_uint = IOUSBBitRange!(0, 3);
958pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkMinSpeedIdPhase: c_uint =
960 IOUSBBitRangePhase!(0, 3);
961pub const kIOUSBSuperSpeedPlusDeviceCapabilityReserved: c_uint = IOUSBBitRange!(4, 7);
963pub const kIOUSBSuperSpeedPlusDeviceCapabilityReservedPhase: c_uint = IOUSBBitRangePhase!(4, 7);
965pub const kIOUSBSuperSpeedPlusDeviceCapabilityMinRxLaneCount: c_uint = IOUSBBitRange!(8, 11);
967pub const kIOUSBSuperSpeedPlusDeviceCapabilityMinRxLaneCountPhase: c_uint =
969 IOUSBBitRangePhase!(8, 11);
970pub const kIOUSBSuperSpeedPlusDeviceCapabilityMinTxLaneCount: c_uint = IOUSBBitRange!(12, 15);
972pub const kIOUSBSuperSpeedPlusDeviceCapabilityMinTxLaneCountPhase: c_uint =
974 IOUSBBitRangePhase!(12, 15);
975pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedId: c_uint = IOUSBBitRange!(0, 3);
977pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedIdPhase: c_uint =
979 IOUSBBitRangePhase!(0, 3);
980pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSE: c_uint = IOUSBBitRange!(4, 5);
982pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEPhase: c_uint = IOUSBBitRangePhase!(4, 5);
984pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEBits: c_uint =
986 0 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEPhase;
987pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEKbits: c_uint =
989 1 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEPhase;
990pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEMbits: c_uint =
992 2 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEPhase;
993pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEGbits: c_uint =
995 3 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkLSEPhase;
996pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkType: c_uint = IOUSBBitRange!(6, 7);
998pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkTypePhase: c_uint = IOUSBBitRangePhase!(6, 7);
1000pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSymmetry: c_uint = IOUSBBit!(6);
1002pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSymmetryPhase: c_uint =
1004 IOUSBBitRangePhase!(6, 6);
1005pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSymmetric: c_uint =
1007 0 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSymmetryPhase;
1008pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkAsymmetric: c_uint =
1010 1 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSymmetryPhase;
1011pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirection: c_uint = IOUSBBit!(7);
1013pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirectionPhase: c_uint =
1015 IOUSBBitRangePhase!(7, 7);
1016pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirectionRx: c_uint =
1018 0 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirectionPhase;
1019pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirectionTx: c_uint =
1021 1 << kIOUSBSuperSpeedPlusDeviceCapabilitySublinkDirectionPhase;
1022pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkReserved: c_uint = IOUSBBitRange!(8, 13);
1024pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkReservedPhase: c_uint =
1026 IOUSBBitRangePhase!(8, 13);
1027pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkProtocol: c_uint = IOUSBBitRange!(14, 15);
1029pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkProtocolPhase: c_uint =
1031 IOUSBBitRangePhase!(14, 15);
1032pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedMantissa: c_uint = IOUSBBitRange!(16, 31);
1034pub const kIOUSBSuperSpeedPlusDeviceCapabilitySublinkSpeedMantissaPhase: c_uint =
1036 IOUSBBitRangePhase!(16, 31);
1037
1038#[repr(C)]
1043#[derive(Clone, Copy, Debug, PartialEq)]
1044pub struct IOUSBDeviceCapabilityContainerID {
1045 pub bLength: u8,
1046 pub bDescriptorType: u8,
1047 pub bDevCapabilityType: u8,
1048 pub bReservedID: u8,
1049 pub containerID: [u8; 16],
1050}
1051
1052#[cfg(feature = "objc2")]
1053unsafe impl Encode for IOUSBDeviceCapabilityContainerID {
1054 const ENCODING: Encoding = Encoding::Struct(
1055 "IOUSBDeviceCapabilityContainerID",
1056 &[
1057 <u8>::ENCODING,
1058 <u8>::ENCODING,
1059 <u8>::ENCODING,
1060 <u8>::ENCODING,
1061 <[u8; 16]>::ENCODING,
1062 ],
1063 );
1064}
1065
1066#[cfg(feature = "objc2")]
1067unsafe impl RefEncode for IOUSBDeviceCapabilityContainerID {
1068 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1069}
1070
1071#[repr(C)]
1076#[derive(Clone, Copy, Debug, PartialEq)]
1077pub struct IOUSBPlatformCapabilityDescriptor {
1078 pub bLength: u8,
1079 pub bDescriptorType: u8,
1080 pub bDevCapabilityType: u8,
1081 pub bReserved: u8,
1082 pub PlatformCapabilityUUID: uuid_t,
1083}
1084
1085#[cfg(feature = "objc2")]
1086unsafe impl Encode for IOUSBPlatformCapabilityDescriptor {
1087 const ENCODING: Encoding = Encoding::Struct(
1088 "IOUSBPlatformCapabilityDescriptor",
1089 &[
1090 <u8>::ENCODING,
1091 <u8>::ENCODING,
1092 <u8>::ENCODING,
1093 <u8>::ENCODING,
1094 <uuid_t>::ENCODING,
1095 ],
1096 );
1097}
1098
1099#[cfg(feature = "objc2")]
1100unsafe impl RefEncode for IOUSBPlatformCapabilityDescriptor {
1101 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1102}
1103
1104#[repr(C, packed)]
1109#[derive(Clone, Copy, Debug, PartialEq)]
1110pub struct IOUSBDeviceCapabilityBillboardAltConfigCompatibility {
1111 pub wSVID: u16,
1112 pub dwAlternateMode: u32,
1113 pub iAlternateModeString: u8,
1114}
1115
1116#[cfg(feature = "objc2")]
1117unsafe impl Encode for IOUSBDeviceCapabilityBillboardAltConfigCompatibility {
1118 const ENCODING: Encoding = Encoding::Struct(
1119 "IOUSBDeviceCapabilityBillboardAltConfigCompatibility",
1120 &[<u16>::ENCODING, <u32>::ENCODING, <u8>::ENCODING],
1121 );
1122}
1123
1124#[cfg(feature = "objc2")]
1125unsafe impl RefEncode for IOUSBDeviceCapabilityBillboardAltConfigCompatibility {
1126 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1127}
1128
1129#[repr(C, packed)]
1134#[derive(Clone, Copy, Debug, PartialEq)]
1135pub struct IOUSBDeviceCapabilityBillboardAltConfig {
1136 pub wSVID: u16,
1137 pub bAltenateMode: u8,
1138 pub iAlternateModeString: u8,
1139}
1140
1141#[cfg(feature = "objc2")]
1142unsafe impl Encode for IOUSBDeviceCapabilityBillboardAltConfig {
1143 const ENCODING: Encoding = Encoding::Struct(
1144 "IOUSBDeviceCapabilityBillboardAltConfig",
1145 &[<u16>::ENCODING, <u8>::ENCODING, <u8>::ENCODING],
1146 );
1147}
1148
1149#[cfg(feature = "objc2")]
1150unsafe impl RefEncode for IOUSBDeviceCapabilityBillboardAltConfig {
1151 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1152}
1153
1154#[repr(C, packed)]
1159#[derive(Clone, Copy, Debug, PartialEq)]
1160pub struct IOUSBDeviceCapabilityBillboard {
1161 pub bLength: u8,
1162 pub bDescriptorType: u8,
1163 pub bDevCapabilityType: u8,
1164 pub iAdditionalInfoURL: u8,
1165 pub bNumberOfAlternateModes: u8,
1166 pub bPreferredAlternateMode: u8,
1167 pub vCONNPower: u16,
1168 pub bmConfigured: [u8; 32],
1169 pub bcdVersion: u16,
1170 pub bAdditionalFailureInfo: u8,
1171 pub bReserved: u8,
1172 pub pAltConfigurations: *mut IOUSBDeviceCapabilityBillboardAltConfig,
1173}
1174
1175#[cfg(feature = "objc2")]
1176unsafe impl Encode for IOUSBDeviceCapabilityBillboard {
1177 const ENCODING: Encoding = Encoding::Struct(
1178 "IOUSBDeviceCapabilityBillboard",
1179 &[
1180 <u8>::ENCODING,
1181 <u8>::ENCODING,
1182 <u8>::ENCODING,
1183 <u8>::ENCODING,
1184 <u8>::ENCODING,
1185 <u8>::ENCODING,
1186 <u16>::ENCODING,
1187 <[u8; 32]>::ENCODING,
1188 <u16>::ENCODING,
1189 <u8>::ENCODING,
1190 <u8>::ENCODING,
1191 <*mut IOUSBDeviceCapabilityBillboardAltConfig>::ENCODING,
1192 ],
1193 );
1194}
1195
1196#[cfg(feature = "objc2")]
1197unsafe impl RefEncode for IOUSBDeviceCapabilityBillboard {
1198 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1199}
1200
1201#[repr(C, packed)]
1206#[derive(Clone, Copy, Debug, PartialEq)]
1207pub struct IOUSBDeviceCapabilityBillboardAltMode {
1208 pub bLength: u8,
1209 pub bDescriptorType: u8,
1210 pub bDevCapabilityType: u8,
1211 pub bIndex: u8,
1212 pub dwAlternateModeVdo: u16,
1213}
1214
1215#[cfg(feature = "objc2")]
1216unsafe impl Encode for IOUSBDeviceCapabilityBillboardAltMode {
1217 const ENCODING: Encoding = Encoding::Struct(
1218 "IOUSBDeviceCapabilityBillboardAltMode",
1219 &[
1220 <u8>::ENCODING,
1221 <u8>::ENCODING,
1222 <u8>::ENCODING,
1223 <u8>::ENCODING,
1224 <u16>::ENCODING,
1225 ],
1226 );
1227}
1228
1229#[cfg(feature = "objc2")]
1230unsafe impl RefEncode for IOUSBDeviceCapabilityBillboardAltMode {
1231 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1232}
1233
1234#[repr(C)]
1244#[derive(Clone, Copy, Debug, PartialEq)]
1245pub struct IOUSBInterfaceAssociationDescriptor {
1246 pub bLength: u8,
1247 pub bDescriptorType: u8,
1248 pub bFirstInterface: u8,
1249 pub bInterfaceCount: u8,
1250 pub bFunctionClass: u8,
1251 pub bFunctionSubClass: u8,
1252 pub bFunctionProtocol: u8,
1253 pub iFunction: u8,
1254}
1255
1256#[cfg(feature = "objc2")]
1257unsafe impl Encode for IOUSBInterfaceAssociationDescriptor {
1258 const ENCODING: Encoding = Encoding::Struct(
1259 "IOUSBInterfaceAssociationDescriptor",
1260 &[
1261 <u8>::ENCODING,
1262 <u8>::ENCODING,
1263 <u8>::ENCODING,
1264 <u8>::ENCODING,
1265 <u8>::ENCODING,
1266 <u8>::ENCODING,
1267 <u8>::ENCODING,
1268 <u8>::ENCODING,
1269 ],
1270 );
1271}
1272
1273#[cfg(feature = "objc2")]
1274unsafe impl RefEncode for IOUSBInterfaceAssociationDescriptor {
1275 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1276}
1277
1278#[repr(C, packed)]
1288#[derive(Clone, Copy, Debug, PartialEq)]
1289pub struct IOUSBSuperSpeedEndpointCompanionDescriptor {
1290 pub bLength: u8,
1291 pub bDescriptorType: u8,
1292 pub bMaxBurst: u8,
1293 pub bmAttributes: u8,
1294 pub wBytesPerInterval: u16,
1295}
1296
1297#[cfg(feature = "objc2")]
1298unsafe impl Encode for IOUSBSuperSpeedEndpointCompanionDescriptor {
1299 const ENCODING: Encoding = Encoding::Struct(
1300 "IOUSBSuperSpeedEndpointCompanionDescriptor",
1301 &[
1302 <u8>::ENCODING,
1303 <u8>::ENCODING,
1304 <u8>::ENCODING,
1305 <u8>::ENCODING,
1306 <u16>::ENCODING,
1307 ],
1308 );
1309}
1310
1311#[cfg(feature = "objc2")]
1312unsafe impl RefEncode for IOUSBSuperSpeedEndpointCompanionDescriptor {
1313 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1314}
1315
1316pub const kIOUSBSuperSpeedEndpointCompanionDescriptorMaxBurst: c_uint = IOUSBBitRange!(0, 4);
1318pub const kIOUSBSuperSpeedEndpointCompanionDescriptorMaxBurstPhase: c_uint =
1320 IOUSBBitRangePhase!(0, 4);
1321pub const kIOUSBSuperSpeedEndpointCompanionDescriptorBulkMaxStreams: c_uint = IOUSBBitRange!(0, 4);
1323pub const kIOUSBSuperSpeedEndpointCompanionDescriptorBulkMaxStreamsPhase: c_uint =
1325 IOUSBBitRangePhase!(0, 4);
1326pub const kIOUSBSuperSpeedEndpointCompanionDescriptorBulkReserved: c_uint = IOUSBBitRange!(5, 7);
1328pub const kIOUSBSuperSpeedEndpointCompanionDescriptorBulkReservedPhase: c_uint =
1330 IOUSBBitRangePhase!(5, 7);
1331pub const kIOUSBSuperSpeedEndpointCompanionDescriptorIsocMult: c_uint = IOUSBBitRange!(0, 1);
1333pub const kIOUSBSuperSpeedEndpointCompanionDescriptorIsocMultPhase: c_uint =
1335 IOUSBBitRangePhase!(0, 1);
1336pub const kIOUSBSuperSpeedEndpointCompanionDescriptorIsocReserved: c_uint = IOUSBBitRange!(2, 6);
1338pub const kIOUSBSuperSpeedEndpointCompanionDescriptorIsocReservedPhase: c_uint =
1340 IOUSBBitRangePhase!(2, 6);
1341pub const kIOUSBSuperSpeedEndpointCompanionDescriptorSSPIsocCompanion: c_uint = IOUSBBit!(7);
1343
1344#[repr(C, packed)]
1354#[derive(Clone, Copy, Debug, PartialEq)]
1355pub struct IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptor {
1356 pub bLength: u8,
1357 pub bDescriptorType: u8,
1358 pub wReserved: u16,
1359 pub dwBytesPerInterval: u32,
1360}
1361
1362#[cfg(feature = "objc2")]
1363unsafe impl Encode for IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptor {
1364 const ENCODING: Encoding = Encoding::Struct(
1365 "IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptor",
1366 &[
1367 <u8>::ENCODING,
1368 <u8>::ENCODING,
1369 <u16>::ENCODING,
1370 <u32>::ENCODING,
1371 ],
1372 );
1373}
1374
1375#[cfg(feature = "objc2")]
1376unsafe impl RefEncode for IOUSBSuperSpeedPlusIsochronousEndpointCompanionDescriptor {
1377 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1378}
1379
1380#[repr(C, packed)]
1390#[derive(Clone, Copy, Debug, PartialEq)]
1391pub struct IOUSB20HubDescriptor {
1392 pub bLength: u8,
1393 pub bDescriptorType: u8,
1394 pub bNumberPorts: u8,
1395 pub wHubCharacteristics: u16,
1396 pub bPowerOnToPowerGood: u8,
1397 pub bHubControllerCurrent: u8,
1398 pub deviceRemovable: [u8; 2],
1399 pub reserved: [u8; 2],
1400}
1401
1402#[cfg(feature = "objc2")]
1403unsafe impl Encode for IOUSB20HubDescriptor {
1404 const ENCODING: Encoding = Encoding::Struct(
1405 "IOUSB20HubDescriptor",
1406 &[
1407 <u8>::ENCODING,
1408 <u8>::ENCODING,
1409 <u8>::ENCODING,
1410 <u16>::ENCODING,
1411 <u8>::ENCODING,
1412 <u8>::ENCODING,
1413 <[u8; 2]>::ENCODING,
1414 <[u8; 2]>::ENCODING,
1415 ],
1416 );
1417}
1418
1419#[cfg(feature = "objc2")]
1420unsafe impl RefEncode for IOUSB20HubDescriptor {
1421 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1422}
1423
1424#[repr(C, packed)]
1434#[derive(Clone, Copy, Debug, PartialEq)]
1435pub struct IOUSBSuperSpeedHubDescriptor {
1436 pub bLength: u8,
1437 pub bDescriptorType: u8,
1438 pub bNumberPorts: u8,
1439 pub wHubCharacteristics: u16,
1440 pub bPowerOnToPowerGood: u8,
1441 pub bHubControllerCurrent: u8,
1442 pub bHubDecodeLatency: u8,
1443 pub wHubDelay: u16,
1444 pub deviceRemovable: u16,
1445}
1446
1447#[cfg(feature = "objc2")]
1448unsafe impl Encode for IOUSBSuperSpeedHubDescriptor {
1449 const ENCODING: Encoding = Encoding::Struct(
1450 "IOUSBSuperSpeedHubDescriptor",
1451 &[
1452 <u8>::ENCODING,
1453 <u8>::ENCODING,
1454 <u8>::ENCODING,
1455 <u16>::ENCODING,
1456 <u8>::ENCODING,
1457 <u8>::ENCODING,
1458 <u8>::ENCODING,
1459 <u16>::ENCODING,
1460 <u16>::ENCODING,
1461 ],
1462 );
1463}
1464
1465#[cfg(feature = "objc2")]
1466unsafe impl RefEncode for IOUSBSuperSpeedHubDescriptor {
1467 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1468}
1469
1470pub const kIOUSBSuperSpeedHubCharacteristicsPowerSwitchingMask: c_uint = IOUSBBitRange!(0, 1);
1472pub const kIOUSBSuperSpeedHubCharacteristicsPowerSwitchingGanged: c_uint =
1474 0 << IOUSBBitRangePhase!(0, 1);
1475pub const kIOUSBSuperSpeedHubCharacteristicsPowerSwitchingIndividual: c_uint =
1477 1 << IOUSBBitRangePhase!(0, 1);
1478pub const kIOUSBSuperSpeedHubCharacteristicsCompoundDevice: c_uint = IOUSBBit!(2);
1480pub const kIOUSBSuperSpeedHubCharacteristicsOverCurrentMask: c_uint = IOUSBBitRange!(3, 4);
1482pub const kIOUSBSuperSpeedHubCharacteristicsOverCurrentGlobal: c_uint =
1484 0 << IOUSBBitRangePhase!(3, 4);
1485pub const kIOUSBSuperSpeedHubCharacteristicsOverCurrentIndividual: c_uint =
1487 1 << IOUSBBitRangePhase!(3, 4);
1488pub const kIOUSBSuperSpeedHubCharacteristicsReserved: c_uint = IOUSBBitRange!(5, 15);
1490pub const kIOUSBSuperSpeedHubDecodeLatencyMax: c_uint = 10;
1492pub const kIOUSBSuperSpeedHubDelayMax: c_uint = 400;
1494
1495#[repr(C)]
1499#[derive(Clone, Copy, Debug, PartialEq)]
1500pub struct UASPipeDescriptor {
1501 pub bLength: u8,
1502 pub bDescriptorType: u8,
1503 pub bPipeID: u8,
1504 pub bReserved: u8,
1505}
1506
1507#[cfg(feature = "objc2")]
1508unsafe impl Encode for UASPipeDescriptor {
1509 const ENCODING: Encoding = Encoding::Struct(
1510 "UASPipeDescriptor",
1511 &[
1512 <u8>::ENCODING,
1513 <u8>::ENCODING,
1514 <u8>::ENCODING,
1515 <u8>::ENCODING,
1516 ],
1517 );
1518}
1519
1520#[cfg(feature = "objc2")]
1521unsafe impl RefEncode for UASPipeDescriptor {
1522 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1523}
1524
1525#[repr(C, packed)]
1533#[derive(Clone, Copy, Debug, PartialEq)]
1534pub struct IOUSBHIDDescriptor {
1535 pub descLen: u8,
1536 pub descType: u8,
1537 pub descVersNum: u16,
1538 pub hidCountryCode: u8,
1539 pub hidNumDescriptors: u8,
1540 pub hidDescriptorType: u8,
1541 pub hidDescriptorLengthLo: u8,
1542 pub hidDescriptorLengthHi: u8,
1543}
1544
1545#[cfg(feature = "objc2")]
1546unsafe impl Encode for IOUSBHIDDescriptor {
1547 const ENCODING: Encoding = Encoding::Struct(
1548 "IOUSBHIDDescriptor",
1549 &[
1550 <u8>::ENCODING,
1551 <u8>::ENCODING,
1552 <u16>::ENCODING,
1553 <u8>::ENCODING,
1554 <u8>::ENCODING,
1555 <u8>::ENCODING,
1556 <u8>::ENCODING,
1557 <u8>::ENCODING,
1558 ],
1559 );
1560}
1561
1562#[cfg(feature = "objc2")]
1563unsafe impl RefEncode for IOUSBHIDDescriptor {
1564 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1565}
1566
1567#[repr(C)]
1575#[derive(Clone, Copy, Debug, PartialEq)]
1576pub struct IOUSBHIDReportDesc {
1577 pub hidDescriptorType: u8,
1578 pub hidDescriptorLengthLo: u8,
1579 pub hidDescriptorLengthHi: u8,
1580}
1581
1582#[cfg(feature = "objc2")]
1583unsafe impl Encode for IOUSBHIDReportDesc {
1584 const ENCODING: Encoding = Encoding::Struct(
1585 "IOUSBHIDReportDesc",
1586 &[<u8>::ENCODING, <u8>::ENCODING, <u8>::ENCODING],
1587 );
1588}
1589
1590#[cfg(feature = "objc2")]
1591unsafe impl RefEncode for IOUSBHIDReportDesc {
1592 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1593}
1594
1595#[repr(C, packed)]
1604#[derive(Clone, Copy, Debug, PartialEq)]
1605pub struct IOUSBDFUDescriptor {
1606 pub bLength: u8,
1607 pub bDescriptorType: u8,
1608 pub bmAttributes: u8,
1609 pub wDetachTimeout: u16,
1610 pub wTransferSize: u16,
1611}
1612
1613#[cfg(feature = "objc2")]
1614unsafe impl Encode for IOUSBDFUDescriptor {
1615 const ENCODING: Encoding = Encoding::Struct(
1616 "IOUSBDFUDescriptor",
1617 &[
1618 <u8>::ENCODING,
1619 <u8>::ENCODING,
1620 <u8>::ENCODING,
1621 <u16>::ENCODING,
1622 <u16>::ENCODING,
1623 ],
1624 );
1625}
1626
1627#[cfg(feature = "objc2")]
1628unsafe impl RefEncode for IOUSBDFUDescriptor {
1629 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1630}
1631
1632#[repr(C, packed)]
1642#[derive(Clone, Copy, Debug, PartialEq)]
1643pub struct IOUSBDeviceRequest {
1644 pub bmRequestType: u8,
1645 pub bRequest: u8,
1646 pub wValue: u16,
1647 pub wIndex: u16,
1648 pub wLength: u16,
1649}
1650
1651#[cfg(feature = "objc2")]
1652unsafe impl Encode for IOUSBDeviceRequest {
1653 const ENCODING: Encoding = Encoding::Struct(
1654 "IOUSBDeviceRequest",
1655 &[
1656 <u8>::ENCODING,
1657 <u8>::ENCODING,
1658 <u16>::ENCODING,
1659 <u16>::ENCODING,
1660 <u16>::ENCODING,
1661 ],
1662 );
1663}
1664
1665#[cfg(feature = "objc2")]
1666unsafe impl RefEncode for IOUSBDeviceRequest {
1667 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1668}
1669
1670#[repr(C, packed)]
1679#[derive(Clone, Copy, Debug, PartialEq)]
1680pub struct IOUSBDeviceRequestSetSELData {
1681 pub u1Sel: u8,
1682 pub u1Pel: u8,
1683 pub u2Sel: u16,
1684 pub u2Pel: u16,
1685}
1686
1687#[cfg(feature = "objc2")]
1688unsafe impl Encode for IOUSBDeviceRequestSetSELData {
1689 const ENCODING: Encoding = Encoding::Struct(
1690 "IOUSBDeviceRequestSetSELData",
1691 &[
1692 <u8>::ENCODING,
1693 <u8>::ENCODING,
1694 <u16>::ENCODING,
1695 <u16>::ENCODING,
1696 ],
1697 );
1698}
1699
1700#[cfg(feature = "objc2")]
1701unsafe impl RefEncode for IOUSBDeviceRequestSetSELData {
1702 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1703}
1704
1705#[repr(transparent)]
1709#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1710pub struct tIOUSBDeviceRequestDirectionValue(pub c_uint);
1711impl tIOUSBDeviceRequestDirectionValue {
1712 #[doc(alias = "kIOUSBDeviceRequestDirectionValueOut")]
1713 pub const IOUSBDeviceRequestDirectionValueOut: Self = Self(0);
1714 #[doc(alias = "kIOUSBDeviceRequestDirectionValueIn")]
1715 pub const IOUSBDeviceRequestDirectionValueIn: Self = Self(1);
1716}
1717
1718#[cfg(feature = "objc2")]
1719unsafe impl Encode for tIOUSBDeviceRequestDirectionValue {
1720 const ENCODING: Encoding = c_uint::ENCODING;
1721}
1722
1723#[cfg(feature = "objc2")]
1724unsafe impl RefEncode for tIOUSBDeviceRequestDirectionValue {
1725 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1726}
1727
1728#[repr(transparent)]
1732#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1733pub struct tIOUSBDeviceRequestTypeValue(pub c_uint);
1734impl tIOUSBDeviceRequestTypeValue {
1735 #[doc(alias = "kIOUSBDeviceRequestTypeValueStandard")]
1736 pub const IOUSBDeviceRequestTypeValueStandard: Self = Self(0);
1737 #[doc(alias = "kIOUSBDeviceRequestTypeValueClass")]
1738 pub const IOUSBDeviceRequestTypeValueClass: Self = Self(1);
1739 #[doc(alias = "kIOUSBDeviceRequestTypeValueVendor")]
1740 pub const IOUSBDeviceRequestTypeValueVendor: Self = Self(2);
1741}
1742
1743#[cfg(feature = "objc2")]
1744unsafe impl Encode for tIOUSBDeviceRequestTypeValue {
1745 const ENCODING: Encoding = c_uint::ENCODING;
1746}
1747
1748#[cfg(feature = "objc2")]
1749unsafe impl RefEncode for tIOUSBDeviceRequestTypeValue {
1750 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1751}
1752
1753#[repr(transparent)]
1757#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1758pub struct tIOUSBDeviceRequestRecipientValue(pub c_uint);
1759impl tIOUSBDeviceRequestRecipientValue {
1760 #[doc(alias = "kIOUSBDeviceRequestRecipientValueDevice")]
1761 pub const IOUSBDeviceRequestRecipientValueDevice: Self = Self(0);
1762 #[doc(alias = "kIOUSBDeviceRequestRecipientValueInterface")]
1763 pub const IOUSBDeviceRequestRecipientValueInterface: Self = Self(1);
1764 #[doc(alias = "kIOUSBDeviceRequestRecipientValueEndpoint")]
1765 pub const IOUSBDeviceRequestRecipientValueEndpoint: Self = Self(2);
1766 #[doc(alias = "kIOUSBDeviceRequestRecipientValueOther")]
1767 pub const IOUSBDeviceRequestRecipientValueOther: Self = Self(3);
1768}
1769
1770#[cfg(feature = "objc2")]
1771unsafe impl Encode for tIOUSBDeviceRequestRecipientValue {
1772 const ENCODING: Encoding = c_uint::ENCODING;
1773}
1774
1775#[cfg(feature = "objc2")]
1776unsafe impl RefEncode for tIOUSBDeviceRequestRecipientValue {
1777 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1778}
1779
1780#[repr(transparent)]
1782#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1783pub struct tIOUSBDeviceRequest(pub c_uint);
1784impl tIOUSBDeviceRequest {
1785 #[doc(alias = "kIOUSBDeviceRequestSize")]
1786 pub const IOUSBDeviceRequestSize: Self = Self(8);
1787 #[doc(alias = "kIOUSBDeviceRequestDirectionMask")]
1788 pub const IOUSBDeviceRequestDirectionMask: Self = Self(IOUSBBit!(7));
1789 #[doc(alias = "kIOUSBDeviceRequestDirectionPhase")]
1790 pub const IOUSBDeviceRequestDirectionPhase: Self = Self(IOUSBBitRangePhase!(7, 7));
1791 #[doc(alias = "kIOUSBDeviceRequestDirectionOut")]
1792 pub const IOUSBDeviceRequestDirectionOut: Self = Self(
1793 tIOUSBDeviceRequestDirectionValue::IOUSBDeviceRequestDirectionValueOut.0
1794 << tIOUSBDeviceRequest::IOUSBDeviceRequestDirectionPhase.0,
1795 );
1796 #[doc(alias = "kIOUSBDeviceRequestDirectionIn")]
1797 pub const IOUSBDeviceRequestDirectionIn: Self = Self(
1798 tIOUSBDeviceRequestDirectionValue::IOUSBDeviceRequestDirectionValueIn.0
1799 << tIOUSBDeviceRequest::IOUSBDeviceRequestDirectionPhase.0,
1800 );
1801 #[doc(alias = "kIOUSBDeviceRequestTypeMask")]
1802 pub const IOUSBDeviceRequestTypeMask: Self = Self(IOUSBBitRange!(5, 6));
1803 #[doc(alias = "kIOUSBDeviceRequestTypePhase")]
1804 pub const IOUSBDeviceRequestTypePhase: Self = Self(IOUSBBitRangePhase!(5, 6));
1805 #[doc(alias = "kIOUSBDeviceRequestTypeStandard")]
1806 pub const IOUSBDeviceRequestTypeStandard: Self = Self(
1807 tIOUSBDeviceRequestTypeValue::IOUSBDeviceRequestTypeValueStandard.0
1808 << tIOUSBDeviceRequest::IOUSBDeviceRequestTypePhase.0,
1809 );
1810 #[doc(alias = "kIOUSBDeviceRequestTypeClass")]
1811 pub const IOUSBDeviceRequestTypeClass: Self = Self(
1812 tIOUSBDeviceRequestTypeValue::IOUSBDeviceRequestTypeValueClass.0
1813 << tIOUSBDeviceRequest::IOUSBDeviceRequestTypePhase.0,
1814 );
1815 #[doc(alias = "kIOUSBDeviceRequestTypeVendor")]
1816 pub const IOUSBDeviceRequestTypeVendor: Self = Self(
1817 tIOUSBDeviceRequestTypeValue::IOUSBDeviceRequestTypeValueVendor.0
1818 << tIOUSBDeviceRequest::IOUSBDeviceRequestTypePhase.0,
1819 );
1820 #[doc(alias = "kIOUSBDeviceRequestRecipientMask")]
1821 pub const IOUSBDeviceRequestRecipientMask: Self = Self(IOUSBBitRange!(0, 4));
1822 #[doc(alias = "kIOUSBDeviceRequestRecipientPhase")]
1823 pub const IOUSBDeviceRequestRecipientPhase: Self = Self(IOUSBBitRangePhase!(0, 4));
1824 #[doc(alias = "kIOUSBDeviceRequestRecipientDevice")]
1825 pub const IOUSBDeviceRequestRecipientDevice: Self = Self(
1826 tIOUSBDeviceRequestRecipientValue::IOUSBDeviceRequestRecipientValueDevice.0
1827 << tIOUSBDeviceRequest::IOUSBDeviceRequestRecipientPhase.0,
1828 );
1829 #[doc(alias = "kIOUSBDeviceRequestRecipientInterface")]
1830 pub const IOUSBDeviceRequestRecipientInterface: Self = Self(
1831 tIOUSBDeviceRequestRecipientValue::IOUSBDeviceRequestRecipientValueInterface.0
1832 << tIOUSBDeviceRequest::IOUSBDeviceRequestRecipientPhase.0,
1833 );
1834 #[doc(alias = "kIOUSBDeviceRequestRecipientEndpoint")]
1835 pub const IOUSBDeviceRequestRecipientEndpoint: Self = Self(
1836 tIOUSBDeviceRequestRecipientValue::IOUSBDeviceRequestRecipientValueEndpoint.0
1837 << tIOUSBDeviceRequest::IOUSBDeviceRequestRecipientPhase.0,
1838 );
1839 #[doc(alias = "kIOUSBDeviceRequestRecipientOther")]
1840 pub const IOUSBDeviceRequestRecipientOther: Self = Self(
1841 tIOUSBDeviceRequestRecipientValue::IOUSBDeviceRequestRecipientValueOther.0
1842 << tIOUSBDeviceRequest::IOUSBDeviceRequestRecipientPhase.0,
1843 );
1844}
1845
1846#[cfg(feature = "objc2")]
1847unsafe impl Encode for tIOUSBDeviceRequest {
1848 const ENCODING: Encoding = c_uint::ENCODING;
1849}
1850
1851#[cfg(feature = "objc2")]
1852unsafe impl RefEncode for tIOUSBDeviceRequest {
1853 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1854}
1855
1856pub const kIOUSBDeviceRequestGetStatus: c_uint = 0;
1858pub const kIOUSBDeviceRequestClearFeature: c_uint = 1;
1860pub const kIOUSBDeviceRequestGetState: c_uint = 2;
1862pub const kIOUSBDeviceRequestSetFeature: c_uint = 3;
1864pub const kIOUSBDeviceRequestSetAddress: c_uint = 5;
1866pub const kIOUSBDeviceRequestGetDescriptor: c_uint = 6;
1868pub const kIOUSBDeviceRequestSetDescriptor: c_uint = 7;
1870pub const kIOUSBDeviceRequestGetConfiguration: c_uint = 8;
1872pub const kIOUSBDeviceRequestSetConfiguration: c_uint = 9;
1874pub const kIOUSBDeviceRequestGetInterface: c_uint = 10;
1876pub const kIOUSBDeviceRequestSetInterface: c_uint = 11;
1878pub const kIOUSBDeviceRequestSynchFrame: c_uint = 12;
1880pub const kIOUSBDeviceRequestSetSel: c_uint = 48;
1882pub const kIOUSBDeviceRequestSetIsochronousDelay: c_uint = 49;
1884
1885pub const kIOUSBDeviceStatusSelfPowered: c_uint = IOUSBBit!(0);
1887pub const kIOUSBDeviceStatusRemoteWakeEnable: c_uint = IOUSBBit!(1);
1889pub const kIOUSBDeviceStatusU1Enable: c_uint = IOUSBBit!(2);
1891pub const kIOUSBDeviceStatusU2Enable: c_uint = IOUSBBit!(3);
1893pub const kIOUSBDeviceStatusLTMEnable: c_uint = IOUSBBit!(4);
1895pub const kIOUSBInterfaceStatusRemoteWakeCapable: c_uint = IOUSBBit!(0);
1897pub const kIOUSBInterfaceStatusRemoteWakeEnable: c_uint = IOUSBBit!(1);
1899pub const IOUSBEndpointStatusHalt: c_uint = IOUSBBit!(0);
1901
1902pub const kIOUSBDeviceFeatureSelectorRemoteWakeup: c_uint = 1;
1904pub const kIOUSBDeviceFeatureSelectorTestMode: c_uint = 2;
1906pub const kIOUSBDeviceFeatureSelectorU1Enable: c_uint = 48;
1908pub const kIOUSBDeviceFeatureSelectorU2Enable: c_uint = 49;
1910pub const kIOUSBDeviceFeatureSelectorLTMEnable: c_uint = 50;
1912pub const kIOUSBInterfaceFeatureSelectorSuspend: c_uint = 0;
1914pub const IOUSBEndpointFeatureSelectorStall: c_uint = 0;
1916
1917pub const kIOUSBInterfaceSuspendLowPower: c_uint = IOUSBBit!(0);
1919pub const kIOUSBInterfaceSuspendRemoteWakeEnable: c_uint = IOUSBBit!(1);
1921
1922pub const kIOUSBHubPort2PortExitLatencyNs: c_uint = 1000;
1924pub const kIOUSBHubDelayNs: c_uint = 400;
1926
1927pub const kIOUSBPingResponseTimeNs: c_uint = 400;
1929
1930#[repr(transparent)]
1932#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1933pub struct tIOUSBBusVoltage(pub c_uint);
1934impl tIOUSBBusVoltage {
1935 #[doc(alias = "kIOUSBBusVoltageDefault")]
1936 pub const IOUSBBusVoltageDefault: Self = Self(5);
1937}
1938
1939#[cfg(feature = "objc2")]
1940unsafe impl Encode for tIOUSBBusVoltage {
1941 const ENCODING: Encoding = c_uint::ENCODING;
1942}
1943
1944#[cfg(feature = "objc2")]
1945unsafe impl RefEncode for tIOUSBBusVoltage {
1946 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1947}
1948
1949#[repr(transparent)]
1951#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1952pub struct tIOUSB20BusCurrent(pub c_uint);
1953impl tIOUSB20BusCurrent {
1954 #[doc(alias = "kIOUSB20BusCurrentMinimum")]
1955 pub const IOUSB20BusCurrentMinimum: Self = Self(100);
1956 #[doc(alias = "kIOUSB20BusCurrentDefault")]
1957 pub const IOUSB20BusCurrentDefault: Self = Self(500);
1958 #[doc(alias = "kIOUSB20BusCurrentMaxPowerUnits")]
1959 pub const IOUSB20BusCurrentMaxPowerUnits: Self = Self(2);
1960}
1961
1962#[cfg(feature = "objc2")]
1963unsafe impl Encode for tIOUSB20BusCurrent {
1964 const ENCODING: Encoding = c_uint::ENCODING;
1965}
1966
1967#[cfg(feature = "objc2")]
1968unsafe impl RefEncode for tIOUSB20BusCurrent {
1969 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1970}
1971
1972#[repr(transparent)]
1974#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1975pub struct tIOUSB30BusCurrent(pub c_uint);
1976impl tIOUSB30BusCurrent {
1977 #[doc(alias = "kIOUSB30BusCurrentMinimum")]
1978 pub const IOUSB30BusCurrentMinimum: Self = Self(150);
1979 #[doc(alias = "kIOUSB30BusCurrentDefault")]
1980 pub const IOUSB30BusCurrentDefault: Self = Self(900);
1981 #[doc(alias = "kIOUSB30BusCurrentMaxPowerUnits")]
1982 pub const IOUSB30BusCurrentMaxPowerUnits: Self = Self(8);
1983}
1984
1985#[cfg(feature = "objc2")]
1986unsafe impl Encode for tIOUSB30BusCurrent {
1987 const ENCODING: Encoding = c_uint::ENCODING;
1988}
1989
1990#[cfg(feature = "objc2")]
1991unsafe impl RefEncode for tIOUSB30BusCurrent {
1992 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1993}
1994
1995#[repr(transparent)]
1997#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1998pub struct tIOUSBTopology(pub c_uint);
1999impl tIOUSBTopology {
2000 #[doc(alias = "kIOUSBTopologyHost")]
2001 pub const IOUSBTopologyHost: Self = Self(1);
2002 #[doc(alias = "kIOUSBTopologyRootPort")]
2003 pub const IOUSBTopologyRootPort: Self = Self(2);
2004 #[doc(alias = "kIOUSBTopology1Hub")]
2005 pub const IOUSBTopology1Hub: Self = Self(3);
2006 #[doc(alias = "kIOUSBTopology2Hub")]
2007 pub const IOUSBTopology2Hub: Self = Self(4);
2008 #[doc(alias = "kIOUSBTopology3Hub")]
2009 pub const IOUSBTopology3Hub: Self = Self(5);
2010 #[doc(alias = "kIOUSBTopology4Hub")]
2011 pub const IOUSBTopology4Hub: Self = Self(6);
2012 #[doc(alias = "kIOUSBTopology5Hub")]
2013 pub const IOUSBTopology5Hub: Self = Self(7);
2014 #[doc(alias = "kIOUSBTopologyTierLimit")]
2015 pub const IOUSBTopologyTierLimit: Self = Self(tIOUSBTopology::IOUSBTopology5Hub.0);
2016}
2017
2018#[cfg(feature = "objc2")]
2019unsafe impl Encode for tIOUSBTopology {
2020 const ENCODING: Encoding = c_uint::ENCODING;
2021}
2022
2023#[cfg(feature = "objc2")]
2024unsafe impl RefEncode for tIOUSBTopology {
2025 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2026}
2027
2028#[repr(transparent)]
2030#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2031pub struct tIOUSB30ResetTimeout(pub c_uint);
2032impl tIOUSB30ResetTimeout {
2033 #[doc(alias = "kIOUSB30ResetMinimumTimeout")]
2034 pub const IOUSB30ResetMinimumTimeout: Self = Self(80);
2035 #[doc(alias = "kIOUSB30ResetTypicalTimeout")]
2036 pub const IOUSB30ResetTypicalTimeout: Self = Self(100);
2037 #[doc(alias = "kIOUSB30ResetMaximumTimeout")]
2038 pub const IOUSB30ResetMaximumTimeout: Self = Self(120);
2039 #[doc(alias = "kIOUSB30ResetMaximumWithMarginTimeout")]
2040 pub const IOUSB30ResetMaximumWithMarginTimeout: Self = Self(150);
2041}
2042
2043#[cfg(feature = "objc2")]
2044unsafe impl Encode for tIOUSB30ResetTimeout {
2045 const ENCODING: Encoding = c_uint::ENCODING;
2046}
2047
2048#[cfg(feature = "objc2")]
2049unsafe impl RefEncode for tIOUSB30ResetTimeout {
2050 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2051}
2052
2053#[repr(transparent)]
2055#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2056pub struct tIOUSB30LinkStateTimeout(pub c_uint);
2057impl tIOUSB30LinkStateTimeout {
2058 #[doc(alias = "kIOUSB30LinkStateSSInactiveQuietTimeout")]
2059 pub const IOUSB30LinkStateSSInactiveQuietTimeout: Self = Self(12);
2060 #[doc(alias = "kIOUSB30LinkStateRxDetectQuietTimeout")]
2061 pub const IOUSB30LinkStateRxDetectQuietTimeout: Self = Self(12);
2062 #[doc(alias = "kIOUSB30LinkStatePollingLFPSTimeout")]
2063 pub const IOUSB30LinkStatePollingLFPSTimeout: Self = Self(360);
2064 #[doc(alias = "kIOUSB30LinkStatePollingActiveTimeout")]
2065 pub const IOUSB30LinkStatePollingActiveTimeout: Self = Self(12);
2066 #[doc(alias = "kIOUSB30LinkStatePollingConfigurationTimeout")]
2067 pub const IOUSB30LinkStatePollingConfigurationTimeout: Self = Self(12);
2068 #[doc(alias = "kIOUSB30LinkStatePollingIdleTimeout")]
2069 pub const IOUSB30LinkStatePollingIdleTimeout: Self = Self(2);
2070 #[doc(alias = "kIOUSB30LinkStateU0RecoveryTimeout")]
2071 pub const IOUSB30LinkStateU0RecoveryTimeout: Self = Self(1);
2072 #[doc(alias = "kIOUSB30LinkStateU0LTimeout")]
2073 pub const IOUSB30LinkStateU0LTimeout: Self = Self(0);
2074 #[doc(alias = "kIOUSB30LinkStateU1NoLFPSResponseTimeout")]
2075 pub const IOUSB30LinkStateU1NoLFPSResponseTimeout: Self = Self(2);
2076 #[doc(alias = "kIOUSB30LinkStateU1PingTimeout")]
2077 pub const IOUSB30LinkStateU1PingTimeout: Self = Self(300);
2078 #[doc(alias = "kIOUSB30LinkStateU2NoLFPSResponseTimeout")]
2079 pub const IOUSB30LinkStateU2NoLFPSResponseTimeout: Self = Self(2);
2080 #[doc(alias = "kIOUSB30LinKStateU2RxDetectDelay")]
2081 pub const IOUSB30LinKStateU2RxDetectDelay: Self = Self(100);
2082 #[doc(alias = "kIOUSB30LinkStateU3NoLFPSResponseTimeout")]
2083 pub const IOUSB30LinkStateU3NoLFPSResponseTimeout: Self = Self(10);
2084 #[doc(alias = "kIOUSB30LinkStateU3WakeupRetryDelay")]
2085 pub const IOUSB30LinkStateU3WakeupRetryDelay: Self = Self(100);
2086 #[doc(alias = "kIOUSB30LinkStateU3RxDetectDelay")]
2087 pub const IOUSB30LinkStateU3RxDetectDelay: Self = Self(100);
2088 #[doc(alias = "kIOUSB30LinkStateRecoveryActiveTimeout")]
2089 pub const IOUSB30LinkStateRecoveryActiveTimeout: Self = Self(12);
2090 #[doc(alias = "kIOUSB30LinkStateRecoveryConfigurationTimeout")]
2091 pub const IOUSB30LinkStateRecoveryConfigurationTimeout: Self = Self(6);
2092 #[doc(alias = "kIOUSB30LinkStateRecoveryIdleTimeout")]
2093 pub const IOUSB30LinkStateRecoveryIdleTimeout: Self = Self(2);
2094 #[doc(alias = "kIOUSB30LinkStateLoopbackExitTimeout")]
2095 pub const IOUSB30LinkStateLoopbackExitTimeout: Self = Self(2);
2096 #[doc(alias = "kIOUSB30LinkStateHotResetActiveTimeout")]
2097 pub const IOUSB30LinkStateHotResetActiveTimeout: Self = Self(12);
2098 #[doc(alias = "kIOUSB30LinkStateHotResetExitTimeout")]
2099 pub const IOUSB30LinkStateHotResetExitTimeout: Self = Self(2);
2100 #[doc(alias = "kIOUSB30LinkStatePollingDeadline")]
2101 pub const IOUSB30LinkStatePollingDeadline: Self = Self(
2102 tIOUSB30LinkStateTimeout::IOUSB30LinkStatePollingLFPSTimeout.0
2103 + 1
2104 + tIOUSB30LinkStateTimeout::IOUSB30LinkStatePollingActiveTimeout.0
2105 + tIOUSB30LinkStateTimeout::IOUSB30LinkStatePollingConfigurationTimeout.0
2106 + tIOUSB30LinkStateTimeout::IOUSB30LinkStatePollingIdleTimeout.0,
2107 );
2108 #[doc(alias = "kIOUSB30LinkStateSSResumeDeadline")]
2109 pub const IOUSB30LinkStateSSResumeDeadline: Self = Self(
2110 tIOUSB30LinkStateTimeout::IOUSB30LinkStateU3WakeupRetryDelay.0+tIOUSB30LinkStateTimeout::IOUSB30LinkStateU3NoLFPSResponseTimeout.0+tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryActiveTimeout.0+tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryConfigurationTimeout.0+tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryIdleTimeout.0,
2111 );
2112 #[doc(alias = "kIOUSB30LinkStateRecoveryDeadline")]
2113 pub const IOUSB30LinkStateRecoveryDeadline: Self = Self(
2114 tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryActiveTimeout.0
2115 + tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryConfigurationTimeout.0
2116 + tIOUSB30LinkStateTimeout::IOUSB30LinkStateRecoveryIdleTimeout.0
2117 + 1, );
2119 #[doc(alias = "kIOUSB30LinkStateHotResetDeadline")]
2120 pub const IOUSB30LinkStateHotResetDeadline: Self = Self(
2121 tIOUSB30LinkStateTimeout::IOUSB30LinkStateHotResetActiveTimeout.0
2122 + tIOUSB30LinkStateTimeout::IOUSB30LinkStateHotResetExitTimeout.0
2123 + 1,
2124 );
2125}
2126
2127#[cfg(feature = "objc2")]
2128unsafe impl Encode for tIOUSB30LinkStateTimeout {
2129 const ENCODING: Encoding = c_uint::ENCODING;
2130}
2131
2132#[cfg(feature = "objc2")]
2133unsafe impl RefEncode for tIOUSB30LinkStateTimeout {
2134 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2135}
2136
2137#[repr(transparent)]
2139#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2140pub struct tIOUSB30DeviceNotificationType(pub c_uint);
2141impl tIOUSB30DeviceNotificationType {
2142 #[doc(alias = "kIOUSB30DeviceNotificationTypeFunctionWake")]
2143 pub const IOUSB30DeviceNotificationTypeFunctionWake: Self = Self(1);
2144 #[doc(alias = "kIOUSB30DeviceNotificationTypeLatencyTolerance")]
2145 pub const IOUSB30DeviceNotificationTypeLatencyTolerance: Self = Self(2);
2146 #[doc(alias = "kIOUSB30DeviceNotificationTypeBusIntervalAdjustment")]
2147 pub const IOUSB30DeviceNotificationTypeBusIntervalAdjustment: Self = Self(3);
2148 #[doc(alias = "kIOUSB30DeviceNotificationTypeHostRoleRequest")]
2149 pub const IOUSB30DeviceNotificationTypeHostRoleRequest: Self = Self(4);
2150 #[doc(alias = "kIOUSB30DeviceNotificationTypeSublinkSpeed")]
2151 pub const IOUSB30DeviceNotificationTypeSublinkSpeed: Self = Self(5);
2152}
2153
2154#[cfg(feature = "objc2")]
2155unsafe impl Encode for tIOUSB30DeviceNotificationType {
2156 const ENCODING: Encoding = c_uint::ENCODING;
2157}
2158
2159#[cfg(feature = "objc2")]
2160unsafe impl RefEncode for tIOUSB30DeviceNotificationType {
2161 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2162}
2163
2164#[repr(transparent)]
2166#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2167pub struct tIOUSB30TimingParameters(pub c_uint);
2168impl tIOUSB30TimingParameters {
2169 #[doc(alias = "kIOUSB30TimingParameterBELTDefaultNs")]
2170 pub const IOUSB30TimingParameterBELTDefaultNs: Self = Self(1 * 1000 * 1000);
2171 #[doc(alias = "kIOUSB30TimingParameterBELTMinNs")]
2172 pub const IOUSB30TimingParameterBELTMinNs: Self = Self(125 * 1000);
2173}
2174
2175#[cfg(feature = "objc2")]
2176unsafe impl Encode for tIOUSB30TimingParameters {
2177 const ENCODING: Encoding = c_uint::ENCODING;
2178}
2179
2180#[cfg(feature = "objc2")]
2181unsafe impl RefEncode for tIOUSB30TimingParameters {
2182 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2183}
2184
2185#[repr(transparent)]
2187#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2188pub struct tIOUSB30HubPortStatusCode(pub c_uint);
2189impl tIOUSB30HubPortStatusCode {
2190 #[doc(alias = "kIOUSB30HubPortStatusCodeStandard")]
2191 pub const IOUSB30HubPortStatusCodeStandard: Self = Self(0);
2192 #[doc(alias = "kIOUSB30HubPortStatusCodePD")]
2193 pub const IOUSB30HubPortStatusCodePD: Self = Self(1);
2194 #[doc(alias = "kIOUSB30HubPortStatusCodeExt")]
2195 pub const IOUSB30HubPortStatusCodeExt: Self = Self(2);
2196 #[doc(alias = "kIOUSB30HubPortStatusCodeCount")]
2197 pub const IOUSB30HubPortStatusCodeCount: Self = Self(3);
2198}
2199
2200#[cfg(feature = "objc2")]
2201unsafe impl Encode for tIOUSB30HubPortStatusCode {
2202 const ENCODING: Encoding = c_uint::ENCODING;
2203}
2204
2205#[cfg(feature = "objc2")]
2206unsafe impl RefEncode for tIOUSB30HubPortStatusCode {
2207 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2208}
2209
2210pub const kIOUSB30RetimerDepthLimit: c_uint = 4;
2212
2213#[repr(C, packed)]
2222#[derive(Clone, Copy, Debug, PartialEq)]
2223pub struct IOUSB30HubPortStatusExt {
2224 pub wPortStatus: u16,
2225 pub wPortChange: u16,
2226 pub dwExtPortStatus: u32,
2227}
2228
2229#[cfg(feature = "objc2")]
2230unsafe impl Encode for IOUSB30HubPortStatusExt {
2231 const ENCODING: Encoding = Encoding::Struct(
2232 "IOUSB30HubPortStatusExt",
2233 &[<u16>::ENCODING, <u16>::ENCODING, <u32>::ENCODING],
2234 );
2235}
2236
2237#[cfg(feature = "objc2")]
2238unsafe impl RefEncode for IOUSB30HubPortStatusExt {
2239 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2240}
2241
2242#[repr(transparent)]
2244#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
2245pub struct tIOUSB30HubExtStatus(pub c_uint);
2246impl tIOUSB30HubExtStatus {
2247 #[doc(alias = "kIOUSB30HubExtStatusRxSublinkSpeedID")]
2248 pub const IOUSB30HubExtStatusRxSublinkSpeedID: Self = Self(IOUSBBitRange!(0, 3));
2249 #[doc(alias = "kIOUSB30HubExtStatusRxSublinkSpeedIDPhase")]
2250 pub const IOUSB30HubExtStatusRxSublinkSpeedIDPhase: Self = Self(IOUSBBitRangePhase!(0, 3));
2251 #[doc(alias = "kIOUSB30HubExtStatusTxSublinkSpeedID")]
2252 pub const IOUSB30HubExtStatusTxSublinkSpeedID: Self = Self(IOUSBBitRange!(4, 7));
2253 #[doc(alias = "kIOUSB30HubExtStatusTxSublinkSpeedIDPhase")]
2254 pub const IOUSB30HubExtStatusTxSublinkSpeedIDPhase: Self = Self(IOUSBBitRangePhase!(4, 7));
2255 #[doc(alias = "kIOUSB30HubExtStatusRxLaneCount")]
2256 pub const IOUSB30HubExtStatusRxLaneCount: Self = Self(IOUSBBitRange!(8, 11));
2257 #[doc(alias = "kIOUSB30HubExtStatusRxLaneCountPhase")]
2258 pub const IOUSB30HubExtStatusRxLaneCountPhase: Self = Self(IOUSBBitRangePhase!(8, 11));
2259 #[doc(alias = "kIOUSB30HubExtStatusTxLaneCount")]
2260 pub const IOUSB30HubExtStatusTxLaneCount: Self = Self(IOUSBBitRange!(12, 15));
2261 #[doc(alias = "kIOUSB30HubExtStatusTxLaneCountPhase")]
2262 pub const IOUSB30HubExtStatusTxLaneCountPhase: Self = Self(IOUSBBitRangePhase!(12, 15));
2263}
2264
2265#[cfg(feature = "objc2")]
2266unsafe impl Encode for tIOUSB30HubExtStatus {
2267 const ENCODING: Encoding = c_uint::ENCODING;
2268}
2269
2270#[cfg(feature = "objc2")]
2271unsafe impl RefEncode for tIOUSB30HubExtStatus {
2272 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2273}