1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " An address of a PCI device.\n"]
8 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 #[repr(C)]
10 pub struct Address {
11 pub bus: u8,
12
13 pub device: u8,
14
15 pub function: u8,
16 }
17
18 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Address, ___E> for Address
19 where
20 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
21 {
22 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Address> = unsafe {
23 ::fidl_next::CopyOptimization::enable_if(
24 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
25 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
26 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
27 )
28 };
29
30 #[inline]
31 fn encode(
32 self,
33 encoder_: &mut ___E,
34 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
35 _: (),
36 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
37 ::fidl_next::munge! {
38 let crate::wire::Address {
39 bus,
40 device,
41 function,
42
43 } = out_;
44 }
45
46 ::fidl_next::Encode::encode(self.bus, encoder_, bus, ())?;
47
48 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus.as_mut_ptr()) };
49
50 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
51
52 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
53
54 ::fidl_next::Encode::encode(self.function, encoder_, function, ())?;
55
56 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function.as_mut_ptr()) };
57
58 Ok(())
59 }
60 }
61
62 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Address, ___E> for &'a Address
63 where
64 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
65 {
66 #[inline]
67 fn encode(
68 self,
69 encoder_: &mut ___E,
70 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
71 _: (),
72 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
73 ::fidl_next::munge! {
74 let crate::wire::Address {
75 bus,
76 device,
77 function,
78
79 } = out_;
80 }
81
82 ::fidl_next::Encode::encode(&self.bus, encoder_, bus, ())?;
83
84 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus.as_mut_ptr()) };
85
86 ::fidl_next::Encode::encode(&self.device, encoder_, device, ())?;
87
88 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
89
90 ::fidl_next::Encode::encode(&self.function, encoder_, function, ())?;
91
92 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function.as_mut_ptr()) };
93
94 Ok(())
95 }
96 }
97
98 unsafe impl<___E>
99 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Address>, ___E>
100 for Address
101 where
102 ___E: ::fidl_next::Encoder + ?Sized,
103 Address: ::fidl_next::Encode<crate::wire::Address, ___E>,
104 {
105 #[inline]
106 fn encode_option(
107 this: ::core::option::Option<Self>,
108 encoder: &mut ___E,
109 out: &mut ::core::mem::MaybeUninit<
110 ::fidl_next::wire::Box<'static, crate::wire::Address>,
111 >,
112 _: (),
113 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
114 if let Some(inner) = this {
115 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
116 ::fidl_next::wire::Box::encode_present(out);
117 } else {
118 ::fidl_next::wire::Box::encode_absent(out);
119 }
120
121 Ok(())
122 }
123 }
124
125 unsafe impl<'a, ___E>
126 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Address>, ___E>
127 for &'a Address
128 where
129 ___E: ::fidl_next::Encoder + ?Sized,
130 &'a Address: ::fidl_next::Encode<crate::wire::Address, ___E>,
131 {
132 #[inline]
133 fn encode_option(
134 this: ::core::option::Option<Self>,
135 encoder: &mut ___E,
136 out: &mut ::core::mem::MaybeUninit<
137 ::fidl_next::wire::Box<'static, crate::wire::Address>,
138 >,
139 _: (),
140 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
141 if let Some(inner) = this {
142 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
143 ::fidl_next::wire::Box::encode_present(out);
144 } else {
145 ::fidl_next::wire::Box::encode_absent(out);
146 }
147
148 Ok(())
149 }
150 }
151
152 impl ::fidl_next::FromWire<crate::wire::Address> for Address {
153 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Address, Self> = unsafe {
154 ::fidl_next::CopyOptimization::enable_if(
155 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
156 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
157 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
158 )
159 };
160
161 #[inline]
162 fn from_wire(wire: crate::wire::Address) -> Self {
163 Self {
164 bus: ::fidl_next::FromWire::from_wire(wire.bus),
165
166 device: ::fidl_next::FromWire::from_wire(wire.device),
167
168 function: ::fidl_next::FromWire::from_wire(wire.function),
169 }
170 }
171 }
172
173 impl ::fidl_next::FromWireRef<crate::wire::Address> for Address {
174 #[inline]
175 fn from_wire_ref(wire: &crate::wire::Address) -> Self {
176 Self {
177 bus: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus),
178
179 device: ::fidl_next::FromWireRef::from_wire_ref(&wire.device),
180
181 function: ::fidl_next::FromWireRef::from_wire_ref(&wire.function),
182 }
183 }
184 }
185
186 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
187 pub struct BaseAddress {
188 pub address: u64,
189
190 pub size: u64,
191
192 pub is_memory: bool,
193
194 pub is_prefetchable: bool,
195
196 pub is_64bit: bool,
197
198 pub id: u8,
199 }
200
201 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BaseAddress, ___E> for BaseAddress
202 where
203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
204 {
205 #[inline]
206 fn encode(
207 self,
208 encoder_: &mut ___E,
209 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
210 _: (),
211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
212 ::fidl_next::munge! {
213 let crate::wire::BaseAddress {
214 address,
215 size,
216 is_memory,
217 is_prefetchable,
218 is_64bit,
219 id,
220
221 } = out_;
222 }
223
224 ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;
225
226 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(address.as_mut_ptr()) };
227
228 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
229
230 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
231
232 ::fidl_next::Encode::encode(self.is_memory, encoder_, is_memory, ())?;
233
234 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_memory.as_mut_ptr()) };
235
236 ::fidl_next::Encode::encode(self.is_prefetchable, encoder_, is_prefetchable, ())?;
237
238 let mut _field =
239 unsafe { ::fidl_next::Slot::new_unchecked(is_prefetchable.as_mut_ptr()) };
240
241 ::fidl_next::Encode::encode(self.is_64bit, encoder_, is_64bit, ())?;
242
243 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_64bit.as_mut_ptr()) };
244
245 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
246
247 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
248
249 Ok(())
250 }
251 }
252
253 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BaseAddress, ___E> for &'a BaseAddress
254 where
255 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
256 {
257 #[inline]
258 fn encode(
259 self,
260 encoder_: &mut ___E,
261 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
262 _: (),
263 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
264 ::fidl_next::munge! {
265 let crate::wire::BaseAddress {
266 address,
267 size,
268 is_memory,
269 is_prefetchable,
270 is_64bit,
271 id,
272
273 } = out_;
274 }
275
276 ::fidl_next::Encode::encode(&self.address, encoder_, address, ())?;
277
278 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(address.as_mut_ptr()) };
279
280 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
281
282 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
283
284 ::fidl_next::Encode::encode(&self.is_memory, encoder_, is_memory, ())?;
285
286 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_memory.as_mut_ptr()) };
287
288 ::fidl_next::Encode::encode(&self.is_prefetchable, encoder_, is_prefetchable, ())?;
289
290 let mut _field =
291 unsafe { ::fidl_next::Slot::new_unchecked(is_prefetchable.as_mut_ptr()) };
292
293 ::fidl_next::Encode::encode(&self.is_64bit, encoder_, is_64bit, ())?;
294
295 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_64bit.as_mut_ptr()) };
296
297 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
298
299 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
300
301 Ok(())
302 }
303 }
304
305 unsafe impl<___E>
306 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::BaseAddress>, ___E>
307 for BaseAddress
308 where
309 ___E: ::fidl_next::Encoder + ?Sized,
310 BaseAddress: ::fidl_next::Encode<crate::wire::BaseAddress, ___E>,
311 {
312 #[inline]
313 fn encode_option(
314 this: ::core::option::Option<Self>,
315 encoder: &mut ___E,
316 out: &mut ::core::mem::MaybeUninit<
317 ::fidl_next::wire::Box<'static, crate::wire::BaseAddress>,
318 >,
319 _: (),
320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
321 if let Some(inner) = this {
322 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
323 ::fidl_next::wire::Box::encode_present(out);
324 } else {
325 ::fidl_next::wire::Box::encode_absent(out);
326 }
327
328 Ok(())
329 }
330 }
331
332 unsafe impl<'a, ___E>
333 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::BaseAddress>, ___E>
334 for &'a BaseAddress
335 where
336 ___E: ::fidl_next::Encoder + ?Sized,
337 &'a BaseAddress: ::fidl_next::Encode<crate::wire::BaseAddress, ___E>,
338 {
339 #[inline]
340 fn encode_option(
341 this: ::core::option::Option<Self>,
342 encoder: &mut ___E,
343 out: &mut ::core::mem::MaybeUninit<
344 ::fidl_next::wire::Box<'static, crate::wire::BaseAddress>,
345 >,
346 _: (),
347 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
348 if let Some(inner) = this {
349 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
350 ::fidl_next::wire::Box::encode_present(out);
351 } else {
352 ::fidl_next::wire::Box::encode_absent(out);
353 }
354
355 Ok(())
356 }
357 }
358
359 impl ::fidl_next::FromWire<crate::wire::BaseAddress> for BaseAddress {
360 #[inline]
361 fn from_wire(wire: crate::wire::BaseAddress) -> Self {
362 Self {
363 address: ::fidl_next::FromWire::from_wire(wire.address),
364
365 size: ::fidl_next::FromWire::from_wire(wire.size),
366
367 is_memory: ::fidl_next::FromWire::from_wire(wire.is_memory),
368
369 is_prefetchable: ::fidl_next::FromWire::from_wire(wire.is_prefetchable),
370
371 is_64bit: ::fidl_next::FromWire::from_wire(wire.is_64bit),
372
373 id: ::fidl_next::FromWire::from_wire(wire.id),
374 }
375 }
376 }
377
378 impl ::fidl_next::FromWireRef<crate::wire::BaseAddress> for BaseAddress {
379 #[inline]
380 fn from_wire_ref(wire: &crate::wire::BaseAddress) -> Self {
381 Self {
382 address: ::fidl_next::FromWireRef::from_wire_ref(&wire.address),
383
384 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
385
386 is_memory: ::fidl_next::FromWireRef::from_wire_ref(&wire.is_memory),
387
388 is_prefetchable: ::fidl_next::FromWireRef::from_wire_ref(&wire.is_prefetchable),
389
390 is_64bit: ::fidl_next::FromWireRef::from_wire_ref(&wire.is_64bit),
391
392 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
393 }
394 }
395 }
396
397 pub type UseIntxWorkaroundType = ();
398
399 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
400 pub struct BoardConfiguration {
401 pub use_intx_workaround: ::core::option::Option<crate::natural::UseIntxWorkaroundType>,
402
403 pub devicetree_bdfs: ::core::option::Option<::std::vec::Vec<crate::natural::Address>>,
404 }
405
406 impl BoardConfiguration {
407 fn __max_ordinal(&self) -> usize {
408 if self.devicetree_bdfs.is_some() {
409 return 2;
410 }
411
412 if self.use_intx_workaround.is_some() {
413 return 1;
414 }
415
416 0
417 }
418 }
419
420 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
421 for BoardConfiguration
422 where
423 ___E: ::fidl_next::Encoder + ?Sized,
424 {
425 #[inline]
426 fn encode(
427 mut self,
428 encoder: &mut ___E,
429 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
430 _: (),
431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
432 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
433
434 let max_ord = self.__max_ordinal();
435
436 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
437 ::fidl_next::Wire::zero_padding(&mut out);
438
439 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
440 ::fidl_next::wire::Envelope,
441 >(encoder, max_ord);
442
443 for i in 1..=max_ord {
444 match i {
445 2 => {
446 if let Some(value) = self.devicetree_bdfs.take() {
447 ::fidl_next::wire::Envelope::encode_value::<
448 ::fidl_next::wire::Vector<'static, crate::wire::Address>,
449 ___E,
450 >(
451 value, preallocated.encoder, &mut out, (4294967295, ())
452 )?;
453 } else {
454 ::fidl_next::wire::Envelope::encode_zero(&mut out)
455 }
456 }
457
458 1 => {
459 if let Some(value) = self.use_intx_workaround.take() {
460 ::fidl_next::wire::Envelope::encode_value::<
461 crate::wire::UseIntxWorkaroundType,
462 ___E,
463 >(
464 value, preallocated.encoder, &mut out, ()
465 )?;
466 } else {
467 ::fidl_next::wire::Envelope::encode_zero(&mut out)
468 }
469 }
470
471 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
472 }
473 unsafe {
474 preallocated.write_next(out.assume_init_ref());
475 }
476 }
477
478 ::fidl_next::wire::Table::encode_len(table, max_ord);
479
480 Ok(())
481 }
482 }
483
484 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
485 for &'a BoardConfiguration
486 where
487 ___E: ::fidl_next::Encoder + ?Sized,
488 {
489 #[inline]
490 fn encode(
491 self,
492 encoder: &mut ___E,
493 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
494 _: (),
495 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
496 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
497
498 let max_ord = self.__max_ordinal();
499
500 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
501 ::fidl_next::Wire::zero_padding(&mut out);
502
503 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
504 ::fidl_next::wire::Envelope,
505 >(encoder, max_ord);
506
507 for i in 1..=max_ord {
508 match i {
509 2 => {
510 if let Some(value) = &self.devicetree_bdfs {
511 ::fidl_next::wire::Envelope::encode_value::<
512 ::fidl_next::wire::Vector<'static, crate::wire::Address>,
513 ___E,
514 >(
515 value, preallocated.encoder, &mut out, (4294967295, ())
516 )?;
517 } else {
518 ::fidl_next::wire::Envelope::encode_zero(&mut out)
519 }
520 }
521
522 1 => {
523 if let Some(value) = &self.use_intx_workaround {
524 ::fidl_next::wire::Envelope::encode_value::<
525 crate::wire::UseIntxWorkaroundType,
526 ___E,
527 >(
528 value, preallocated.encoder, &mut out, ()
529 )?;
530 } else {
531 ::fidl_next::wire::Envelope::encode_zero(&mut out)
532 }
533 }
534
535 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
536 }
537 unsafe {
538 preallocated.write_next(out.assume_init_ref());
539 }
540 }
541
542 ::fidl_next::wire::Table::encode_len(table, max_ord);
543
544 Ok(())
545 }
546 }
547
548 impl<'de> ::fidl_next::FromWire<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
549 #[inline]
550 fn from_wire(wire_: crate::wire::BoardConfiguration<'de>) -> Self {
551 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
552
553 let use_intx_workaround = wire_.table.get(1);
554
555 let devicetree_bdfs = wire_.table.get(2);
556
557 Self {
558 use_intx_workaround: use_intx_workaround.map(|envelope| {
559 ::fidl_next::FromWire::from_wire(unsafe {
560 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
561 })
562 }),
563
564 devicetree_bdfs: devicetree_bdfs.map(|envelope| {
565 ::fidl_next::FromWire::from_wire(unsafe {
566 envelope
567 .read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>(
568 )
569 })
570 }),
571 }
572 }
573 }
574
575 impl<'de> ::fidl_next::FromWireRef<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
576 #[inline]
577 fn from_wire_ref(wire: &crate::wire::BoardConfiguration<'de>) -> Self {
578 Self {
579
580
581 use_intx_workaround: wire.table.get(1)
582 .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
583 unsafe { envelope.deref_unchecked::<crate::wire::UseIntxWorkaroundType>() }
584 )),
585
586
587 devicetree_bdfs: wire.table.get(2)
588 .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
589 unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>() }
590 )),
591
592 }
593 }
594 }
595
596 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
597 pub struct HostBridgeInfo {
598 pub name: ::std::string::String,
599
600 pub start_bus_number: u8,
601
602 pub end_bus_number: u8,
603
604 pub segment_group: u16,
605 }
606
607 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E> for HostBridgeInfo
608 where
609 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
610 ___E: ::fidl_next::Encoder,
611 {
612 #[inline]
613 fn encode(
614 self,
615 encoder_: &mut ___E,
616 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
617 _: (),
618 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
619 ::fidl_next::munge! {
620 let crate::wire::HostBridgeInfo {
621 name,
622 start_bus_number,
623 end_bus_number,
624 segment_group,
625
626 } = out_;
627 }
628
629 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
630
631 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
632 ::fidl_next::Constrained::validate(_field, 32)?;
633
634 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
635
636 let mut _field =
637 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
638
639 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
640
641 let mut _field =
642 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
643
644 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
645
646 let mut _field =
647 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
648
649 Ok(())
650 }
651 }
652
653 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
654 for &'a HostBridgeInfo
655 where
656 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
657 ___E: ::fidl_next::Encoder,
658 {
659 #[inline]
660 fn encode(
661 self,
662 encoder_: &mut ___E,
663 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
664 _: (),
665 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
666 ::fidl_next::munge! {
667 let crate::wire::HostBridgeInfo {
668 name,
669 start_bus_number,
670 end_bus_number,
671 segment_group,
672
673 } = out_;
674 }
675
676 ::fidl_next::Encode::encode(&self.name, encoder_, name, 32)?;
677
678 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
679 ::fidl_next::Constrained::validate(_field, 32)?;
680
681 ::fidl_next::Encode::encode(&self.start_bus_number, encoder_, start_bus_number, ())?;
682
683 let mut _field =
684 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
685
686 ::fidl_next::Encode::encode(&self.end_bus_number, encoder_, end_bus_number, ())?;
687
688 let mut _field =
689 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
690
691 ::fidl_next::Encode::encode(&self.segment_group, encoder_, segment_group, ())?;
692
693 let mut _field =
694 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
695
696 Ok(())
697 }
698 }
699
700 unsafe impl<___E>
701 ::fidl_next::EncodeOption<
702 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
703 ___E,
704 > for HostBridgeInfo
705 where
706 ___E: ::fidl_next::Encoder + ?Sized,
707 HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
708 {
709 #[inline]
710 fn encode_option(
711 this: ::core::option::Option<Self>,
712 encoder: &mut ___E,
713 out: &mut ::core::mem::MaybeUninit<
714 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
715 >,
716 _: (),
717 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
718 if let Some(inner) = this {
719 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
720 ::fidl_next::wire::Box::encode_present(out);
721 } else {
722 ::fidl_next::wire::Box::encode_absent(out);
723 }
724
725 Ok(())
726 }
727 }
728
729 unsafe impl<'a, ___E>
730 ::fidl_next::EncodeOption<
731 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
732 ___E,
733 > for &'a HostBridgeInfo
734 where
735 ___E: ::fidl_next::Encoder + ?Sized,
736 &'a HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
737 {
738 #[inline]
739 fn encode_option(
740 this: ::core::option::Option<Self>,
741 encoder: &mut ___E,
742 out: &mut ::core::mem::MaybeUninit<
743 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
744 >,
745 _: (),
746 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
747 if let Some(inner) = this {
748 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
749 ::fidl_next::wire::Box::encode_present(out);
750 } else {
751 ::fidl_next::wire::Box::encode_absent(out);
752 }
753
754 Ok(())
755 }
756 }
757
758 impl<'de> ::fidl_next::FromWire<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
759 #[inline]
760 fn from_wire(wire: crate::wire::HostBridgeInfo<'de>) -> Self {
761 Self {
762 name: ::fidl_next::FromWire::from_wire(wire.name),
763
764 start_bus_number: ::fidl_next::FromWire::from_wire(wire.start_bus_number),
765
766 end_bus_number: ::fidl_next::FromWire::from_wire(wire.end_bus_number),
767
768 segment_group: ::fidl_next::FromWire::from_wire(wire.segment_group),
769 }
770 }
771 }
772
773 impl<'de> ::fidl_next::FromWireRef<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
774 #[inline]
775 fn from_wire_ref(wire: &crate::wire::HostBridgeInfo<'de>) -> Self {
776 Self {
777 name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
778
779 start_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_bus_number),
780
781 end_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.end_bus_number),
782
783 segment_group: ::fidl_next::FromWireRef::from_wire_ref(&wire.segment_group),
784 }
785 }
786 }
787
788 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
789 pub struct BusGetHostBridgeInfoResponse {
790 pub info: crate::natural::HostBridgeInfo,
791 }
792
793 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
794 for BusGetHostBridgeInfoResponse
795 where
796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
797 ___E: ::fidl_next::Encoder,
798 {
799 #[inline]
800 fn encode(
801 self,
802 encoder_: &mut ___E,
803 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
804 _: (),
805 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
806 ::fidl_next::munge! {
807 let crate::wire::BusGetHostBridgeInfoResponse {
808 info,
809
810 } = out_;
811 }
812
813 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
814
815 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
816
817 Ok(())
818 }
819 }
820
821 unsafe impl<'a, ___E>
822 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
823 for &'a BusGetHostBridgeInfoResponse
824 where
825 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
826 ___E: ::fidl_next::Encoder,
827 {
828 #[inline]
829 fn encode(
830 self,
831 encoder_: &mut ___E,
832 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
833 _: (),
834 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
835 ::fidl_next::munge! {
836 let crate::wire::BusGetHostBridgeInfoResponse {
837 info,
838
839 } = out_;
840 }
841
842 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
843
844 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
845
846 Ok(())
847 }
848 }
849
850 unsafe impl<___E>
851 ::fidl_next::EncodeOption<
852 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
853 ___E,
854 > for BusGetHostBridgeInfoResponse
855 where
856 ___E: ::fidl_next::Encoder + ?Sized,
857 BusGetHostBridgeInfoResponse:
858 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>,
859 {
860 #[inline]
861 fn encode_option(
862 this: ::core::option::Option<Self>,
863 encoder: &mut ___E,
864 out: &mut ::core::mem::MaybeUninit<
865 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
866 >,
867 _: (),
868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
869 if let Some(inner) = this {
870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
871 ::fidl_next::wire::Box::encode_present(out);
872 } else {
873 ::fidl_next::wire::Box::encode_absent(out);
874 }
875
876 Ok(())
877 }
878 }
879
880 unsafe impl<'a, ___E>
881 ::fidl_next::EncodeOption<
882 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
883 ___E,
884 > for &'a BusGetHostBridgeInfoResponse
885 where
886 ___E: ::fidl_next::Encoder + ?Sized,
887 &'a BusGetHostBridgeInfoResponse:
888 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>,
889 {
890 #[inline]
891 fn encode_option(
892 this: ::core::option::Option<Self>,
893 encoder: &mut ___E,
894 out: &mut ::core::mem::MaybeUninit<
895 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
896 >,
897 _: (),
898 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
899 if let Some(inner) = this {
900 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
901 ::fidl_next::wire::Box::encode_present(out);
902 } else {
903 ::fidl_next::wire::Box::encode_absent(out);
904 }
905
906 Ok(())
907 }
908 }
909
910 impl<'de> ::fidl_next::FromWire<crate::wire::BusGetHostBridgeInfoResponse<'de>>
911 for BusGetHostBridgeInfoResponse
912 {
913 #[inline]
914 fn from_wire(wire: crate::wire::BusGetHostBridgeInfoResponse<'de>) -> Self {
915 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
916 }
917 }
918
919 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusGetHostBridgeInfoResponse<'de>>
920 for BusGetHostBridgeInfoResponse
921 {
922 #[inline]
923 fn from_wire_ref(wire: &crate::wire::BusGetHostBridgeInfoResponse<'de>) -> Self {
924 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
925 }
926 }
927
928 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
929 #[repr(C)]
930 pub struct Capability {
931 pub id: u8,
932
933 pub offset: u8,
934 }
935
936 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability
937 where
938 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
939 {
940 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Capability> = unsafe {
941 ::fidl_next::CopyOptimization::enable_if(
942 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
943 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
944 )
945 };
946
947 #[inline]
948 fn encode(
949 self,
950 encoder_: &mut ___E,
951 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
952 _: (),
953 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
954 ::fidl_next::munge! {
955 let crate::wire::Capability {
956 id,
957 offset,
958
959 } = out_;
960 }
961
962 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
963
964 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
965
966 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
967
968 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
969
970 Ok(())
971 }
972 }
973
974 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for &'a Capability
975 where
976 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
977 {
978 #[inline]
979 fn encode(
980 self,
981 encoder_: &mut ___E,
982 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
983 _: (),
984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
985 ::fidl_next::munge! {
986 let crate::wire::Capability {
987 id,
988 offset,
989
990 } = out_;
991 }
992
993 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
994
995 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
996
997 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
998
999 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1000
1001 Ok(())
1002 }
1003 }
1004
1005 unsafe impl<___E>
1006 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
1007 for Capability
1008 where
1009 ___E: ::fidl_next::Encoder + ?Sized,
1010 Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
1011 {
1012 #[inline]
1013 fn encode_option(
1014 this: ::core::option::Option<Self>,
1015 encoder: &mut ___E,
1016 out: &mut ::core::mem::MaybeUninit<
1017 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
1018 >,
1019 _: (),
1020 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1021 if let Some(inner) = this {
1022 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1023 ::fidl_next::wire::Box::encode_present(out);
1024 } else {
1025 ::fidl_next::wire::Box::encode_absent(out);
1026 }
1027
1028 Ok(())
1029 }
1030 }
1031
1032 unsafe impl<'a, ___E>
1033 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
1034 for &'a Capability
1035 where
1036 ___E: ::fidl_next::Encoder + ?Sized,
1037 &'a Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
1038 {
1039 #[inline]
1040 fn encode_option(
1041 this: ::core::option::Option<Self>,
1042 encoder: &mut ___E,
1043 out: &mut ::core::mem::MaybeUninit<
1044 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
1045 >,
1046 _: (),
1047 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1048 if let Some(inner) = this {
1049 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1050 ::fidl_next::wire::Box::encode_present(out);
1051 } else {
1052 ::fidl_next::wire::Box::encode_absent(out);
1053 }
1054
1055 Ok(())
1056 }
1057 }
1058
1059 impl ::fidl_next::FromWire<crate::wire::Capability> for Capability {
1060 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Capability, Self> = unsafe {
1061 ::fidl_next::CopyOptimization::enable_if(
1062 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
1063 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
1064 )
1065 };
1066
1067 #[inline]
1068 fn from_wire(wire: crate::wire::Capability) -> Self {
1069 Self {
1070 id: ::fidl_next::FromWire::from_wire(wire.id),
1071
1072 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1073 }
1074 }
1075 }
1076
1077 impl ::fidl_next::FromWireRef<crate::wire::Capability> for Capability {
1078 #[inline]
1079 fn from_wire_ref(wire: &crate::wire::Capability) -> Self {
1080 Self {
1081 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1082
1083 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1084 }
1085 }
1086 }
1087
1088 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1089 #[repr(C)]
1090 pub struct ExtendedCapability {
1091 pub id: u16,
1092
1093 pub offset: u16,
1094 }
1095
1096 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E> for ExtendedCapability
1097 where
1098 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1099 {
1100 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1101 Self,
1102 crate::wire::ExtendedCapability,
1103 > = unsafe {
1104 ::fidl_next::CopyOptimization::enable_if(
1105 true
1106
1107 && <
1108 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1109 >::COPY_OPTIMIZATION.is_enabled()
1110
1111 && <
1112 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1113 >::COPY_OPTIMIZATION.is_enabled()
1114
1115 )
1116 };
1117
1118 #[inline]
1119 fn encode(
1120 self,
1121 encoder_: &mut ___E,
1122 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1123 _: (),
1124 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1125 ::fidl_next::munge! {
1126 let crate::wire::ExtendedCapability {
1127 id,
1128 offset,
1129
1130 } = out_;
1131 }
1132
1133 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1134
1135 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1136
1137 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1138
1139 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1140
1141 Ok(())
1142 }
1143 }
1144
1145 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
1146 for &'a ExtendedCapability
1147 where
1148 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1149 {
1150 #[inline]
1151 fn encode(
1152 self,
1153 encoder_: &mut ___E,
1154 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1155 _: (),
1156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1157 ::fidl_next::munge! {
1158 let crate::wire::ExtendedCapability {
1159 id,
1160 offset,
1161
1162 } = out_;
1163 }
1164
1165 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1166
1167 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1168
1169 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
1170
1171 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1172
1173 Ok(())
1174 }
1175 }
1176
1177 unsafe impl<___E>
1178 ::fidl_next::EncodeOption<
1179 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1180 ___E,
1181 > for ExtendedCapability
1182 where
1183 ___E: ::fidl_next::Encoder + ?Sized,
1184 ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1185 {
1186 #[inline]
1187 fn encode_option(
1188 this: ::core::option::Option<Self>,
1189 encoder: &mut ___E,
1190 out: &mut ::core::mem::MaybeUninit<
1191 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1192 >,
1193 _: (),
1194 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1195 if let Some(inner) = this {
1196 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1197 ::fidl_next::wire::Box::encode_present(out);
1198 } else {
1199 ::fidl_next::wire::Box::encode_absent(out);
1200 }
1201
1202 Ok(())
1203 }
1204 }
1205
1206 unsafe impl<'a, ___E>
1207 ::fidl_next::EncodeOption<
1208 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1209 ___E,
1210 > for &'a ExtendedCapability
1211 where
1212 ___E: ::fidl_next::Encoder + ?Sized,
1213 &'a ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1214 {
1215 #[inline]
1216 fn encode_option(
1217 this: ::core::option::Option<Self>,
1218 encoder: &mut ___E,
1219 out: &mut ::core::mem::MaybeUninit<
1220 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1221 >,
1222 _: (),
1223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1224 if let Some(inner) = this {
1225 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1226 ::fidl_next::wire::Box::encode_present(out);
1227 } else {
1228 ::fidl_next::wire::Box::encode_absent(out);
1229 }
1230
1231 Ok(())
1232 }
1233 }
1234
1235 impl ::fidl_next::FromWire<crate::wire::ExtendedCapability> for ExtendedCapability {
1236 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1237 crate::wire::ExtendedCapability,
1238 Self,
1239 > = unsafe {
1240 ::fidl_next::CopyOptimization::enable_if(
1241 true
1242 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1243 .is_enabled()
1244 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1245 .is_enabled(),
1246 )
1247 };
1248
1249 #[inline]
1250 fn from_wire(wire: crate::wire::ExtendedCapability) -> Self {
1251 Self {
1252 id: ::fidl_next::FromWire::from_wire(wire.id),
1253
1254 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1255 }
1256 }
1257 }
1258
1259 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapability> for ExtendedCapability {
1260 #[inline]
1261 fn from_wire_ref(wire: &crate::wire::ExtendedCapability) -> Self {
1262 Self {
1263 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1264
1265 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1266 }
1267 }
1268 }
1269
1270 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1271 pub struct PciDevice {
1272 pub base_addresses: ::std::vec::Vec<crate::natural::BaseAddress>,
1273
1274 pub capabilities: ::std::vec::Vec<crate::natural::Capability>,
1275
1276 pub ext_capabilities: ::std::vec::Vec<crate::natural::ExtendedCapability>,
1277
1278 pub config: ::std::vec::Vec<u8>,
1279
1280 pub bus_id: u8,
1281
1282 pub device_id: u8,
1283
1284 pub function_id: u8,
1285 }
1286
1287 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for PciDevice
1288 where
1289 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1290 ___E: ::fidl_next::Encoder,
1291 {
1292 #[inline]
1293 fn encode(
1294 self,
1295 encoder_: &mut ___E,
1296 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
1297 _: (),
1298 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1299 ::fidl_next::munge! {
1300 let crate::wire::PciDevice {
1301 base_addresses,
1302 capabilities,
1303 ext_capabilities,
1304 config,
1305 bus_id,
1306 device_id,
1307 function_id,
1308
1309 } = out_;
1310 }
1311
1312 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
1313
1314 let mut _field =
1315 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
1316 ::fidl_next::Constrained::validate(_field, (6, ()))?;
1317
1318 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
1319
1320 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
1321 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1322
1323 ::fidl_next::Encode::encode(
1324 self.ext_capabilities,
1325 encoder_,
1326 ext_capabilities,
1327 (32, ()),
1328 )?;
1329
1330 let mut _field =
1331 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
1332 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1333
1334 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
1335
1336 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
1337 ::fidl_next::Constrained::validate(_field, (256, ()))?;
1338
1339 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
1340
1341 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
1342
1343 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
1344
1345 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
1346
1347 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
1348
1349 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
1350
1351 Ok(())
1352 }
1353 }
1354
1355 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for &'a PciDevice
1356 where
1357 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1358 ___E: ::fidl_next::Encoder,
1359 {
1360 #[inline]
1361 fn encode(
1362 self,
1363 encoder_: &mut ___E,
1364 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
1365 _: (),
1366 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1367 ::fidl_next::munge! {
1368 let crate::wire::PciDevice {
1369 base_addresses,
1370 capabilities,
1371 ext_capabilities,
1372 config,
1373 bus_id,
1374 device_id,
1375 function_id,
1376
1377 } = out_;
1378 }
1379
1380 ::fidl_next::Encode::encode(&self.base_addresses, encoder_, base_addresses, (6, ()))?;
1381
1382 let mut _field =
1383 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
1384 ::fidl_next::Constrained::validate(_field, (6, ()))?;
1385
1386 ::fidl_next::Encode::encode(&self.capabilities, encoder_, capabilities, (32, ()))?;
1387
1388 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
1389 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1390
1391 ::fidl_next::Encode::encode(
1392 &self.ext_capabilities,
1393 encoder_,
1394 ext_capabilities,
1395 (32, ()),
1396 )?;
1397
1398 let mut _field =
1399 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
1400 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1401
1402 ::fidl_next::Encode::encode(&self.config, encoder_, config, (256, ()))?;
1403
1404 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
1405 ::fidl_next::Constrained::validate(_field, (256, ()))?;
1406
1407 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
1408
1409 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
1410
1411 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
1412
1413 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
1414
1415 ::fidl_next::Encode::encode(&self.function_id, encoder_, function_id, ())?;
1416
1417 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
1418
1419 Ok(())
1420 }
1421 }
1422
1423 unsafe impl<___E>
1424 ::fidl_next::EncodeOption<
1425 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1426 ___E,
1427 > for PciDevice
1428 where
1429 ___E: ::fidl_next::Encoder + ?Sized,
1430 PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
1431 {
1432 #[inline]
1433 fn encode_option(
1434 this: ::core::option::Option<Self>,
1435 encoder: &mut ___E,
1436 out: &mut ::core::mem::MaybeUninit<
1437 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1438 >,
1439 _: (),
1440 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1441 if let Some(inner) = this {
1442 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1443 ::fidl_next::wire::Box::encode_present(out);
1444 } else {
1445 ::fidl_next::wire::Box::encode_absent(out);
1446 }
1447
1448 Ok(())
1449 }
1450 }
1451
1452 unsafe impl<'a, ___E>
1453 ::fidl_next::EncodeOption<
1454 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1455 ___E,
1456 > for &'a PciDevice
1457 where
1458 ___E: ::fidl_next::Encoder + ?Sized,
1459 &'a PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
1460 {
1461 #[inline]
1462 fn encode_option(
1463 this: ::core::option::Option<Self>,
1464 encoder: &mut ___E,
1465 out: &mut ::core::mem::MaybeUninit<
1466 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1467 >,
1468 _: (),
1469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1470 if let Some(inner) = this {
1471 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1472 ::fidl_next::wire::Box::encode_present(out);
1473 } else {
1474 ::fidl_next::wire::Box::encode_absent(out);
1475 }
1476
1477 Ok(())
1478 }
1479 }
1480
1481 impl<'de> ::fidl_next::FromWire<crate::wire::PciDevice<'de>> for PciDevice {
1482 #[inline]
1483 fn from_wire(wire: crate::wire::PciDevice<'de>) -> Self {
1484 Self {
1485 base_addresses: ::fidl_next::FromWire::from_wire(wire.base_addresses),
1486
1487 capabilities: ::fidl_next::FromWire::from_wire(wire.capabilities),
1488
1489 ext_capabilities: ::fidl_next::FromWire::from_wire(wire.ext_capabilities),
1490
1491 config: ::fidl_next::FromWire::from_wire(wire.config),
1492
1493 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
1494
1495 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
1496
1497 function_id: ::fidl_next::FromWire::from_wire(wire.function_id),
1498 }
1499 }
1500 }
1501
1502 impl<'de> ::fidl_next::FromWireRef<crate::wire::PciDevice<'de>> for PciDevice {
1503 #[inline]
1504 fn from_wire_ref(wire: &crate::wire::PciDevice<'de>) -> Self {
1505 Self {
1506 base_addresses: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_addresses),
1507
1508 capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.capabilities),
1509
1510 ext_capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.ext_capabilities),
1511
1512 config: ::fidl_next::FromWireRef::from_wire_ref(&wire.config),
1513
1514 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
1515
1516 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
1517
1518 function_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.function_id),
1519 }
1520 }
1521 }
1522
1523 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1524 pub struct BusGetDevicesResponse {
1525 pub devices: ::std::vec::Vec<crate::natural::PciDevice>,
1526 }
1527
1528 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
1529 for BusGetDevicesResponse
1530 where
1531 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1532 ___E: ::fidl_next::Encoder,
1533 {
1534 #[inline]
1535 fn encode(
1536 self,
1537 encoder_: &mut ___E,
1538 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
1539 _: (),
1540 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1541 ::fidl_next::munge! {
1542 let crate::wire::BusGetDevicesResponse {
1543 devices,
1544
1545 } = out_;
1546 }
1547
1548 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
1549
1550 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
1551 ::fidl_next::Constrained::validate(_field, (64, ()))?;
1552
1553 Ok(())
1554 }
1555 }
1556
1557 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
1558 for &'a BusGetDevicesResponse
1559 where
1560 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1561 ___E: ::fidl_next::Encoder,
1562 {
1563 #[inline]
1564 fn encode(
1565 self,
1566 encoder_: &mut ___E,
1567 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
1568 _: (),
1569 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1570 ::fidl_next::munge! {
1571 let crate::wire::BusGetDevicesResponse {
1572 devices,
1573
1574 } = out_;
1575 }
1576
1577 ::fidl_next::Encode::encode(&self.devices, encoder_, devices, (64, ()))?;
1578
1579 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
1580 ::fidl_next::Constrained::validate(_field, (64, ()))?;
1581
1582 Ok(())
1583 }
1584 }
1585
1586 unsafe impl<___E>
1587 ::fidl_next::EncodeOption<
1588 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1589 ___E,
1590 > for BusGetDevicesResponse
1591 where
1592 ___E: ::fidl_next::Encoder + ?Sized,
1593 BusGetDevicesResponse:
1594 ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>,
1595 {
1596 #[inline]
1597 fn encode_option(
1598 this: ::core::option::Option<Self>,
1599 encoder: &mut ___E,
1600 out: &mut ::core::mem::MaybeUninit<
1601 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1602 >,
1603 _: (),
1604 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1605 if let Some(inner) = this {
1606 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1607 ::fidl_next::wire::Box::encode_present(out);
1608 } else {
1609 ::fidl_next::wire::Box::encode_absent(out);
1610 }
1611
1612 Ok(())
1613 }
1614 }
1615
1616 unsafe impl<'a, ___E>
1617 ::fidl_next::EncodeOption<
1618 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1619 ___E,
1620 > for &'a BusGetDevicesResponse
1621 where
1622 ___E: ::fidl_next::Encoder + ?Sized,
1623 &'a BusGetDevicesResponse:
1624 ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>,
1625 {
1626 #[inline]
1627 fn encode_option(
1628 this: ::core::option::Option<Self>,
1629 encoder: &mut ___E,
1630 out: &mut ::core::mem::MaybeUninit<
1631 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1632 >,
1633 _: (),
1634 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1635 if let Some(inner) = this {
1636 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1637 ::fidl_next::wire::Box::encode_present(out);
1638 } else {
1639 ::fidl_next::wire::Box::encode_absent(out);
1640 }
1641
1642 Ok(())
1643 }
1644 }
1645
1646 impl<'de> ::fidl_next::FromWire<crate::wire::BusGetDevicesResponse<'de>> for BusGetDevicesResponse {
1647 #[inline]
1648 fn from_wire(wire: crate::wire::BusGetDevicesResponse<'de>) -> Self {
1649 Self { devices: ::fidl_next::FromWire::from_wire(wire.devices) }
1650 }
1651 }
1652
1653 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusGetDevicesResponse<'de>>
1654 for BusGetDevicesResponse
1655 {
1656 #[inline]
1657 fn from_wire_ref(wire: &crate::wire::BusGetDevicesResponse<'de>) -> Self {
1658 Self { devices: ::fidl_next::FromWireRef::from_wire_ref(&wire.devices) }
1659 }
1660 }
1661
1662 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1663 pub struct BusReadBarRequest {
1664 pub device: crate::natural::Address,
1665
1666 pub bar_id: u8,
1667
1668 pub offset: u64,
1669
1670 pub size: u64,
1671 }
1672
1673 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E> for BusReadBarRequest
1674 where
1675 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1676 {
1677 #[inline]
1678 fn encode(
1679 self,
1680 encoder_: &mut ___E,
1681 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
1682 _: (),
1683 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1684 ::fidl_next::munge! {
1685 let crate::wire::BusReadBarRequest {
1686 device,
1687 bar_id,
1688 offset,
1689 size,
1690
1691 } = out_;
1692 }
1693
1694 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
1695
1696 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
1697
1698 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
1699
1700 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
1701
1702 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1703
1704 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1705
1706 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
1707
1708 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
1709
1710 Ok(())
1711 }
1712 }
1713
1714 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>
1715 for &'a BusReadBarRequest
1716 where
1717 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1718 {
1719 #[inline]
1720 fn encode(
1721 self,
1722 encoder_: &mut ___E,
1723 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
1724 _: (),
1725 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1726 ::fidl_next::munge! {
1727 let crate::wire::BusReadBarRequest {
1728 device,
1729 bar_id,
1730 offset,
1731 size,
1732
1733 } = out_;
1734 }
1735
1736 ::fidl_next::Encode::encode(&self.device, encoder_, device, ())?;
1737
1738 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
1739
1740 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
1741
1742 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
1743
1744 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
1745
1746 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1747
1748 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
1749
1750 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
1751
1752 Ok(())
1753 }
1754 }
1755
1756 unsafe impl<___E>
1757 ::fidl_next::EncodeOption<
1758 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1759 ___E,
1760 > for BusReadBarRequest
1761 where
1762 ___E: ::fidl_next::Encoder + ?Sized,
1763 BusReadBarRequest: ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>,
1764 {
1765 #[inline]
1766 fn encode_option(
1767 this: ::core::option::Option<Self>,
1768 encoder: &mut ___E,
1769 out: &mut ::core::mem::MaybeUninit<
1770 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1771 >,
1772 _: (),
1773 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1774 if let Some(inner) = this {
1775 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1776 ::fidl_next::wire::Box::encode_present(out);
1777 } else {
1778 ::fidl_next::wire::Box::encode_absent(out);
1779 }
1780
1781 Ok(())
1782 }
1783 }
1784
1785 unsafe impl<'a, ___E>
1786 ::fidl_next::EncodeOption<
1787 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1788 ___E,
1789 > for &'a BusReadBarRequest
1790 where
1791 ___E: ::fidl_next::Encoder + ?Sized,
1792 &'a BusReadBarRequest: ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>,
1793 {
1794 #[inline]
1795 fn encode_option(
1796 this: ::core::option::Option<Self>,
1797 encoder: &mut ___E,
1798 out: &mut ::core::mem::MaybeUninit<
1799 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1800 >,
1801 _: (),
1802 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1803 if let Some(inner) = this {
1804 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1805 ::fidl_next::wire::Box::encode_present(out);
1806 } else {
1807 ::fidl_next::wire::Box::encode_absent(out);
1808 }
1809
1810 Ok(())
1811 }
1812 }
1813
1814 impl ::fidl_next::FromWire<crate::wire::BusReadBarRequest> for BusReadBarRequest {
1815 #[inline]
1816 fn from_wire(wire: crate::wire::BusReadBarRequest) -> Self {
1817 Self {
1818 device: ::fidl_next::FromWire::from_wire(wire.device),
1819
1820 bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id),
1821
1822 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1823
1824 size: ::fidl_next::FromWire::from_wire(wire.size),
1825 }
1826 }
1827 }
1828
1829 impl ::fidl_next::FromWireRef<crate::wire::BusReadBarRequest> for BusReadBarRequest {
1830 #[inline]
1831 fn from_wire_ref(wire: &crate::wire::BusReadBarRequest) -> Self {
1832 Self {
1833 device: ::fidl_next::FromWireRef::from_wire_ref(&wire.device),
1834
1835 bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id),
1836
1837 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1838
1839 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
1840 }
1841 }
1842 }
1843
1844 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1845 pub struct BusReadBarResponse {
1846 pub buffer: ::std::vec::Vec<u8>,
1847 }
1848
1849 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
1850 for BusReadBarResponse
1851 where
1852 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1853 ___E: ::fidl_next::Encoder,
1854 {
1855 #[inline]
1856 fn encode(
1857 self,
1858 encoder_: &mut ___E,
1859 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
1860 _: (),
1861 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1862 ::fidl_next::munge! {
1863 let crate::wire::BusReadBarResponse {
1864 buffer,
1865
1866 } = out_;
1867 }
1868
1869 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
1870
1871 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
1872 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1873
1874 Ok(())
1875 }
1876 }
1877
1878 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
1879 for &'a BusReadBarResponse
1880 where
1881 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1882 ___E: ::fidl_next::Encoder,
1883 {
1884 #[inline]
1885 fn encode(
1886 self,
1887 encoder_: &mut ___E,
1888 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
1889 _: (),
1890 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1891 ::fidl_next::munge! {
1892 let crate::wire::BusReadBarResponse {
1893 buffer,
1894
1895 } = out_;
1896 }
1897
1898 ::fidl_next::Encode::encode(&self.buffer, encoder_, buffer, (4294967295, ()))?;
1899
1900 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
1901 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1902
1903 Ok(())
1904 }
1905 }
1906
1907 unsafe impl<___E>
1908 ::fidl_next::EncodeOption<
1909 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1910 ___E,
1911 > for BusReadBarResponse
1912 where
1913 ___E: ::fidl_next::Encoder + ?Sized,
1914 BusReadBarResponse: ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>,
1915 {
1916 #[inline]
1917 fn encode_option(
1918 this: ::core::option::Option<Self>,
1919 encoder: &mut ___E,
1920 out: &mut ::core::mem::MaybeUninit<
1921 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1922 >,
1923 _: (),
1924 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1925 if let Some(inner) = this {
1926 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1927 ::fidl_next::wire::Box::encode_present(out);
1928 } else {
1929 ::fidl_next::wire::Box::encode_absent(out);
1930 }
1931
1932 Ok(())
1933 }
1934 }
1935
1936 unsafe impl<'a, ___E>
1937 ::fidl_next::EncodeOption<
1938 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1939 ___E,
1940 > for &'a BusReadBarResponse
1941 where
1942 ___E: ::fidl_next::Encoder + ?Sized,
1943 &'a BusReadBarResponse: ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>,
1944 {
1945 #[inline]
1946 fn encode_option(
1947 this: ::core::option::Option<Self>,
1948 encoder: &mut ___E,
1949 out: &mut ::core::mem::MaybeUninit<
1950 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1951 >,
1952 _: (),
1953 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1954 if let Some(inner) = this {
1955 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1956 ::fidl_next::wire::Box::encode_present(out);
1957 } else {
1958 ::fidl_next::wire::Box::encode_absent(out);
1959 }
1960
1961 Ok(())
1962 }
1963 }
1964
1965 impl<'de> ::fidl_next::FromWire<crate::wire::BusReadBarResponse<'de>> for BusReadBarResponse {
1966 #[inline]
1967 fn from_wire(wire: crate::wire::BusReadBarResponse<'de>) -> Self {
1968 Self { buffer: ::fidl_next::FromWire::from_wire(wire.buffer) }
1969 }
1970 }
1971
1972 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusReadBarResponse<'de>> for BusReadBarResponse {
1973 #[inline]
1974 fn from_wire_ref(wire: &crate::wire::BusReadBarResponse<'de>) -> Self {
1975 Self { buffer: ::fidl_next::FromWireRef::from_wire_ref(&wire.buffer) }
1976 }
1977 }
1978
1979 #[doc = " PCI Capability ID.\n PCI Local Bus Specification v3, appendex H.\n"]
1980 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1981 #[repr(u8)]
1982 pub enum CapabilityId {
1983 Null = 0,
1984 PciPwrMgmt = 1,
1985 Agp = 2,
1986 VitalProductData = 3,
1987 SlotIdentification = 4,
1988 Msi = 5,
1989 CompactPciHotswap = 6,
1990 Pcix = 7,
1991 Hypertransport = 8,
1992 Vendor = 9,
1993 DebugPort = 10,
1994 CompactPciCrc = 11,
1995 PciHotPlug = 12,
1996 PciBridgeSubsystemVid = 13,
1997 Agp8X = 14,
1998 SecureDevice = 15,
1999 PciExpress = 16,
2000 Msix = 17,
2001 SataDataNdxCfg = 18,
2002 AdvancedFeatures = 19,
2003 EnhancedAllocation = 20,
2004 FlatteningPortalBridge = 21,
2005 UnknownOrdinal_(u8) = 22,
2006 }
2007 impl ::std::convert::From<u8> for CapabilityId {
2008 fn from(value: u8) -> Self {
2009 match value {
2010 0 => Self::Null,
2011 1 => Self::PciPwrMgmt,
2012 2 => Self::Agp,
2013 3 => Self::VitalProductData,
2014 4 => Self::SlotIdentification,
2015 5 => Self::Msi,
2016 6 => Self::CompactPciHotswap,
2017 7 => Self::Pcix,
2018 8 => Self::Hypertransport,
2019 9 => Self::Vendor,
2020 10 => Self::DebugPort,
2021 11 => Self::CompactPciCrc,
2022 12 => Self::PciHotPlug,
2023 13 => Self::PciBridgeSubsystemVid,
2024 14 => Self::Agp8X,
2025 15 => Self::SecureDevice,
2026 16 => Self::PciExpress,
2027 17 => Self::Msix,
2028 18 => Self::SataDataNdxCfg,
2029 19 => Self::AdvancedFeatures,
2030 20 => Self::EnhancedAllocation,
2031 21 => Self::FlatteningPortalBridge,
2032
2033 _ => Self::UnknownOrdinal_(value),
2034 }
2035 }
2036 }
2037
2038 impl ::std::convert::From<CapabilityId> for u8 {
2039 fn from(value: CapabilityId) -> Self {
2040 match value {
2041 CapabilityId::Null => 0,
2042 CapabilityId::PciPwrMgmt => 1,
2043 CapabilityId::Agp => 2,
2044 CapabilityId::VitalProductData => 3,
2045 CapabilityId::SlotIdentification => 4,
2046 CapabilityId::Msi => 5,
2047 CapabilityId::CompactPciHotswap => 6,
2048 CapabilityId::Pcix => 7,
2049 CapabilityId::Hypertransport => 8,
2050 CapabilityId::Vendor => 9,
2051 CapabilityId::DebugPort => 10,
2052 CapabilityId::CompactPciCrc => 11,
2053 CapabilityId::PciHotPlug => 12,
2054 CapabilityId::PciBridgeSubsystemVid => 13,
2055 CapabilityId::Agp8X => 14,
2056 CapabilityId::SecureDevice => 15,
2057 CapabilityId::PciExpress => 16,
2058 CapabilityId::Msix => 17,
2059 CapabilityId::SataDataNdxCfg => 18,
2060 CapabilityId::AdvancedFeatures => 19,
2061 CapabilityId::EnhancedAllocation => 20,
2062 CapabilityId::FlatteningPortalBridge => 21,
2063
2064 CapabilityId::UnknownOrdinal_(value) => value,
2065 }
2066 }
2067 }
2068
2069 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for CapabilityId
2070 where
2071 ___E: ?Sized,
2072 {
2073 #[inline]
2074 fn encode(
2075 self,
2076 encoder: &mut ___E,
2077 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
2078 _: (),
2079 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2080 ::fidl_next::Encode::encode(&self, encoder, out, ())
2081 }
2082 }
2083
2084 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for &'a CapabilityId
2085 where
2086 ___E: ?Sized,
2087 {
2088 #[inline]
2089 fn encode(
2090 self,
2091 encoder: &mut ___E,
2092 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
2093 _: (),
2094 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2095 ::fidl_next::munge!(let crate::wire::CapabilityId { value } = out);
2096 let _ = value.write(u8::from(match *self {
2097 CapabilityId::Null => 0,
2098
2099 CapabilityId::PciPwrMgmt => 1,
2100
2101 CapabilityId::Agp => 2,
2102
2103 CapabilityId::VitalProductData => 3,
2104
2105 CapabilityId::SlotIdentification => 4,
2106
2107 CapabilityId::Msi => 5,
2108
2109 CapabilityId::CompactPciHotswap => 6,
2110
2111 CapabilityId::Pcix => 7,
2112
2113 CapabilityId::Hypertransport => 8,
2114
2115 CapabilityId::Vendor => 9,
2116
2117 CapabilityId::DebugPort => 10,
2118
2119 CapabilityId::CompactPciCrc => 11,
2120
2121 CapabilityId::PciHotPlug => 12,
2122
2123 CapabilityId::PciBridgeSubsystemVid => 13,
2124
2125 CapabilityId::Agp8X => 14,
2126
2127 CapabilityId::SecureDevice => 15,
2128
2129 CapabilityId::PciExpress => 16,
2130
2131 CapabilityId::Msix => 17,
2132
2133 CapabilityId::SataDataNdxCfg => 18,
2134
2135 CapabilityId::AdvancedFeatures => 19,
2136
2137 CapabilityId::EnhancedAllocation => 20,
2138
2139 CapabilityId::FlatteningPortalBridge => 21,
2140
2141 CapabilityId::UnknownOrdinal_(value) => value,
2142 }));
2143
2144 Ok(())
2145 }
2146 }
2147
2148 impl ::core::convert::From<crate::wire::CapabilityId> for CapabilityId {
2149 fn from(wire: crate::wire::CapabilityId) -> Self {
2150 match u8::from(wire.value) {
2151 0 => Self::Null,
2152
2153 1 => Self::PciPwrMgmt,
2154
2155 2 => Self::Agp,
2156
2157 3 => Self::VitalProductData,
2158
2159 4 => Self::SlotIdentification,
2160
2161 5 => Self::Msi,
2162
2163 6 => Self::CompactPciHotswap,
2164
2165 7 => Self::Pcix,
2166
2167 8 => Self::Hypertransport,
2168
2169 9 => Self::Vendor,
2170
2171 10 => Self::DebugPort,
2172
2173 11 => Self::CompactPciCrc,
2174
2175 12 => Self::PciHotPlug,
2176
2177 13 => Self::PciBridgeSubsystemVid,
2178
2179 14 => Self::Agp8X,
2180
2181 15 => Self::SecureDevice,
2182
2183 16 => Self::PciExpress,
2184
2185 17 => Self::Msix,
2186
2187 18 => Self::SataDataNdxCfg,
2188
2189 19 => Self::AdvancedFeatures,
2190
2191 20 => Self::EnhancedAllocation,
2192
2193 21 => Self::FlatteningPortalBridge,
2194
2195 value => Self::UnknownOrdinal_(value),
2196 }
2197 }
2198 }
2199
2200 impl ::fidl_next::FromWire<crate::wire::CapabilityId> for CapabilityId {
2201 #[inline]
2202 fn from_wire(wire: crate::wire::CapabilityId) -> Self {
2203 Self::from(wire)
2204 }
2205 }
2206
2207 impl ::fidl_next::FromWireRef<crate::wire::CapabilityId> for CapabilityId {
2208 #[inline]
2209 fn from_wire_ref(wire: &crate::wire::CapabilityId) -> Self {
2210 Self::from(*wire)
2211 }
2212 }
2213
2214 ::fidl_next::bitflags::bitflags! {
2215 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Command: u16 {
2216 const IO_EN = 1;
2217 const MEM_EN = 2;
2218 const BUS_MASTER_EN = 4;
2219 const SPECIAL_EN = 8;
2220 const MEM_WR_INV_EN = 16;
2221 const PAL_SNOOP_EN = 32;
2222 const PERR_RESP_EN = 64;
2223 const AD_STEP_EN = 128;
2224 const SERR_EN = 256;
2225 const FAST_B2_B_EN = 512;
2226 const _ = !0;
2227 }
2228 }
2229
2230 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Command, ___E> for Command
2231 where
2232 ___E: ?Sized,
2233 {
2234 #[inline]
2235 fn encode(
2236 self,
2237 encoder: &mut ___E,
2238 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
2239 _: (),
2240 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2241 ::fidl_next::Encode::encode(&self, encoder, out, ())
2242 }
2243 }
2244
2245 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Command, ___E> for &'a Command
2246 where
2247 ___E: ?Sized,
2248 {
2249 #[inline]
2250 fn encode(
2251 self,
2252 _: &mut ___E,
2253 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
2254 _: (),
2255 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2256 ::fidl_next::munge!(let crate::wire::Command { value } = out);
2257
2258 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
2259 Ok(())
2260 }
2261 }
2262
2263 impl ::core::convert::From<crate::wire::Command> for Command {
2264 fn from(wire: crate::wire::Command) -> Self {
2265 Self::from_bits_retain(u16::from(wire.value))
2266 }
2267 }
2268
2269 impl ::fidl_next::FromWire<crate::wire::Command> for Command {
2270 #[inline]
2271 fn from_wire(wire: crate::wire::Command) -> Self {
2272 Self::from(wire)
2273 }
2274 }
2275
2276 impl ::fidl_next::FromWireRef<crate::wire::Command> for Command {
2277 #[inline]
2278 fn from_wire_ref(wire: &crate::wire::Command) -> Self {
2279 Self::from(*wire)
2280 }
2281 }
2282
2283 #[doc = " PCI Configuration Header registers.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
2284 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2285 #[repr(u16)]
2286 pub enum Config {
2287 VendorId = 0,
2288 DeviceId = 2,
2289 Command = 4,
2290 Status = 6,
2291 RevisionId = 8,
2292 ClassCodeIntr = 9,
2293 ClassCodeSub = 10,
2294 ClassCodeBase = 11,
2295 CacheLineSize = 12,
2296 LatencyTimer = 13,
2297 HeaderType = 14,
2298 Bist = 15,
2299 BaseAddresses = 16,
2300 CardbusCisPtr = 40,
2301 SubsystemVendorId = 44,
2302 SubsystemId = 46,
2303 ExpRomAddress = 48,
2304 CapabilitiesPtr = 52,
2305 InterruptLine = 60,
2306 InterruptPin = 61,
2307 MinGrant = 62,
2308 MaxLatency = 63,
2309 UnknownOrdinal_(u16) = 64,
2310 }
2311 impl ::std::convert::From<u16> for Config {
2312 fn from(value: u16) -> Self {
2313 match value {
2314 0 => Self::VendorId,
2315 2 => Self::DeviceId,
2316 4 => Self::Command,
2317 6 => Self::Status,
2318 8 => Self::RevisionId,
2319 9 => Self::ClassCodeIntr,
2320 10 => Self::ClassCodeSub,
2321 11 => Self::ClassCodeBase,
2322 12 => Self::CacheLineSize,
2323 13 => Self::LatencyTimer,
2324 14 => Self::HeaderType,
2325 15 => Self::Bist,
2326 16 => Self::BaseAddresses,
2327 40 => Self::CardbusCisPtr,
2328 44 => Self::SubsystemVendorId,
2329 46 => Self::SubsystemId,
2330 48 => Self::ExpRomAddress,
2331 52 => Self::CapabilitiesPtr,
2332 60 => Self::InterruptLine,
2333 61 => Self::InterruptPin,
2334 62 => Self::MinGrant,
2335 63 => Self::MaxLatency,
2336
2337 _ => Self::UnknownOrdinal_(value),
2338 }
2339 }
2340 }
2341
2342 impl ::std::convert::From<Config> for u16 {
2343 fn from(value: Config) -> Self {
2344 match value {
2345 Config::VendorId => 0,
2346 Config::DeviceId => 2,
2347 Config::Command => 4,
2348 Config::Status => 6,
2349 Config::RevisionId => 8,
2350 Config::ClassCodeIntr => 9,
2351 Config::ClassCodeSub => 10,
2352 Config::ClassCodeBase => 11,
2353 Config::CacheLineSize => 12,
2354 Config::LatencyTimer => 13,
2355 Config::HeaderType => 14,
2356 Config::Bist => 15,
2357 Config::BaseAddresses => 16,
2358 Config::CardbusCisPtr => 40,
2359 Config::SubsystemVendorId => 44,
2360 Config::SubsystemId => 46,
2361 Config::ExpRomAddress => 48,
2362 Config::CapabilitiesPtr => 52,
2363 Config::InterruptLine => 60,
2364 Config::InterruptPin => 61,
2365 Config::MinGrant => 62,
2366 Config::MaxLatency => 63,
2367
2368 Config::UnknownOrdinal_(value) => value,
2369 }
2370 }
2371 }
2372
2373 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Config, ___E> for Config
2374 where
2375 ___E: ?Sized,
2376 {
2377 #[inline]
2378 fn encode(
2379 self,
2380 encoder: &mut ___E,
2381 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
2382 _: (),
2383 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2384 ::fidl_next::Encode::encode(&self, encoder, out, ())
2385 }
2386 }
2387
2388 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Config, ___E> for &'a Config
2389 where
2390 ___E: ?Sized,
2391 {
2392 #[inline]
2393 fn encode(
2394 self,
2395 encoder: &mut ___E,
2396 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
2397 _: (),
2398 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2399 ::fidl_next::munge!(let crate::wire::Config { value } = out);
2400 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
2401 Config::VendorId => 0,
2402
2403 Config::DeviceId => 2,
2404
2405 Config::Command => 4,
2406
2407 Config::Status => 6,
2408
2409 Config::RevisionId => 8,
2410
2411 Config::ClassCodeIntr => 9,
2412
2413 Config::ClassCodeSub => 10,
2414
2415 Config::ClassCodeBase => 11,
2416
2417 Config::CacheLineSize => 12,
2418
2419 Config::LatencyTimer => 13,
2420
2421 Config::HeaderType => 14,
2422
2423 Config::Bist => 15,
2424
2425 Config::BaseAddresses => 16,
2426
2427 Config::CardbusCisPtr => 40,
2428
2429 Config::SubsystemVendorId => 44,
2430
2431 Config::SubsystemId => 46,
2432
2433 Config::ExpRomAddress => 48,
2434
2435 Config::CapabilitiesPtr => 52,
2436
2437 Config::InterruptLine => 60,
2438
2439 Config::InterruptPin => 61,
2440
2441 Config::MinGrant => 62,
2442
2443 Config::MaxLatency => 63,
2444
2445 Config::UnknownOrdinal_(value) => value,
2446 }));
2447
2448 Ok(())
2449 }
2450 }
2451
2452 impl ::core::convert::From<crate::wire::Config> for Config {
2453 fn from(wire: crate::wire::Config) -> Self {
2454 match u16::from(wire.value) {
2455 0 => Self::VendorId,
2456
2457 2 => Self::DeviceId,
2458
2459 4 => Self::Command,
2460
2461 6 => Self::Status,
2462
2463 8 => Self::RevisionId,
2464
2465 9 => Self::ClassCodeIntr,
2466
2467 10 => Self::ClassCodeSub,
2468
2469 11 => Self::ClassCodeBase,
2470
2471 12 => Self::CacheLineSize,
2472
2473 13 => Self::LatencyTimer,
2474
2475 14 => Self::HeaderType,
2476
2477 15 => Self::Bist,
2478
2479 16 => Self::BaseAddresses,
2480
2481 40 => Self::CardbusCisPtr,
2482
2483 44 => Self::SubsystemVendorId,
2484
2485 46 => Self::SubsystemId,
2486
2487 48 => Self::ExpRomAddress,
2488
2489 52 => Self::CapabilitiesPtr,
2490
2491 60 => Self::InterruptLine,
2492
2493 61 => Self::InterruptPin,
2494
2495 62 => Self::MinGrant,
2496
2497 63 => Self::MaxLatency,
2498
2499 value => Self::UnknownOrdinal_(value),
2500 }
2501 }
2502 }
2503
2504 impl ::fidl_next::FromWire<crate::wire::Config> for Config {
2505 #[inline]
2506 fn from_wire(wire: crate::wire::Config) -> Self {
2507 Self::from(wire)
2508 }
2509 }
2510
2511 impl ::fidl_next::FromWireRef<crate::wire::Config> for Config {
2512 #[inline]
2513 fn from_wire_ref(wire: &crate::wire::Config) -> Self {
2514 Self::from(*wire)
2515 }
2516 }
2517
2518 #[doc = " An offset from the beginning of a device\'s PCI configuration space. [0, 0x100) is valid.\n"]
2519 pub type ConfigOffset = u8;
2520
2521 pub type Padding = ();
2522
2523 #[doc = " Device specific information from a device\'s configuration header.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
2524 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2525 #[repr(C)]
2526 pub struct DeviceInfo {
2527 pub vendor_id: u16,
2528
2529 pub device_id: u16,
2530
2531 pub base_class: u8,
2532
2533 pub sub_class: u8,
2534
2535 pub program_interface: u8,
2536
2537 pub revision_id: u8,
2538
2539 pub bus_id: u8,
2540
2541 pub dev_id: u8,
2542
2543 pub func_id: u8,
2544
2545 pub padding: crate::natural::Padding,
2546 }
2547
2548 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for DeviceInfo
2549 where
2550 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2551 {
2552 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DeviceInfo> = unsafe {
2553 ::fidl_next::CopyOptimization::enable_if(
2554 true
2555
2556 && <
2557 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2558 >::COPY_OPTIMIZATION.is_enabled()
2559
2560 && <
2561 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2562 >::COPY_OPTIMIZATION.is_enabled()
2563
2564 && <
2565 u8 as ::fidl_next::Encode<u8, ___E>
2566 >::COPY_OPTIMIZATION.is_enabled()
2567
2568 && <
2569 u8 as ::fidl_next::Encode<u8, ___E>
2570 >::COPY_OPTIMIZATION.is_enabled()
2571
2572 && <
2573 u8 as ::fidl_next::Encode<u8, ___E>
2574 >::COPY_OPTIMIZATION.is_enabled()
2575
2576 && <
2577 u8 as ::fidl_next::Encode<u8, ___E>
2578 >::COPY_OPTIMIZATION.is_enabled()
2579
2580 && <
2581 u8 as ::fidl_next::Encode<u8, ___E>
2582 >::COPY_OPTIMIZATION.is_enabled()
2583
2584 && <
2585 u8 as ::fidl_next::Encode<u8, ___E>
2586 >::COPY_OPTIMIZATION.is_enabled()
2587
2588 && <
2589 u8 as ::fidl_next::Encode<u8, ___E>
2590 >::COPY_OPTIMIZATION.is_enabled()
2591
2592 && <
2593 crate::natural::Padding as ::fidl_next::Encode<crate::wire::Padding, ___E>
2594 >::COPY_OPTIMIZATION.is_enabled()
2595
2596 )
2597 };
2598
2599 #[inline]
2600 fn encode(
2601 self,
2602 encoder_: &mut ___E,
2603 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2604 _: (),
2605 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2606 ::fidl_next::munge! {
2607 let crate::wire::DeviceInfo {
2608 vendor_id,
2609 device_id,
2610 base_class,
2611 sub_class,
2612 program_interface,
2613 revision_id,
2614 bus_id,
2615 dev_id,
2616 func_id,
2617 padding,
2618
2619 } = out_;
2620 }
2621
2622 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
2623
2624 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2625
2626 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
2627
2628 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2629
2630 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
2631
2632 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2633
2634 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
2635
2636 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2637
2638 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
2639
2640 let mut _field =
2641 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2642
2643 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
2644
2645 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2646
2647 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
2648
2649 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2650
2651 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
2652
2653 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2654
2655 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
2656
2657 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2658
2659 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
2660
2661 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2662
2663 Ok(())
2664 }
2665 }
2666
2667 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for &'a DeviceInfo
2668 where
2669 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2670 {
2671 #[inline]
2672 fn encode(
2673 self,
2674 encoder_: &mut ___E,
2675 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2676 _: (),
2677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2678 ::fidl_next::munge! {
2679 let crate::wire::DeviceInfo {
2680 vendor_id,
2681 device_id,
2682 base_class,
2683 sub_class,
2684 program_interface,
2685 revision_id,
2686 bus_id,
2687 dev_id,
2688 func_id,
2689 padding,
2690
2691 } = out_;
2692 }
2693
2694 ::fidl_next::Encode::encode(&self.vendor_id, encoder_, vendor_id, ())?;
2695
2696 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2697
2698 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
2699
2700 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2701
2702 ::fidl_next::Encode::encode(&self.base_class, encoder_, base_class, ())?;
2703
2704 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2705
2706 ::fidl_next::Encode::encode(&self.sub_class, encoder_, sub_class, ())?;
2707
2708 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2709
2710 ::fidl_next::Encode::encode(&self.program_interface, encoder_, program_interface, ())?;
2711
2712 let mut _field =
2713 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2714
2715 ::fidl_next::Encode::encode(&self.revision_id, encoder_, revision_id, ())?;
2716
2717 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2718
2719 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
2720
2721 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2722
2723 ::fidl_next::Encode::encode(&self.dev_id, encoder_, dev_id, ())?;
2724
2725 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2726
2727 ::fidl_next::Encode::encode(&self.func_id, encoder_, func_id, ())?;
2728
2729 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2730
2731 ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
2732
2733 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2734
2735 Ok(())
2736 }
2737 }
2738
2739 unsafe impl<___E>
2740 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2741 for DeviceInfo
2742 where
2743 ___E: ::fidl_next::Encoder + ?Sized,
2744 DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2745 {
2746 #[inline]
2747 fn encode_option(
2748 this: ::core::option::Option<Self>,
2749 encoder: &mut ___E,
2750 out: &mut ::core::mem::MaybeUninit<
2751 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2752 >,
2753 _: (),
2754 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2755 if let Some(inner) = this {
2756 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2757 ::fidl_next::wire::Box::encode_present(out);
2758 } else {
2759 ::fidl_next::wire::Box::encode_absent(out);
2760 }
2761
2762 Ok(())
2763 }
2764 }
2765
2766 unsafe impl<'a, ___E>
2767 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2768 for &'a DeviceInfo
2769 where
2770 ___E: ::fidl_next::Encoder + ?Sized,
2771 &'a DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2772 {
2773 #[inline]
2774 fn encode_option(
2775 this: ::core::option::Option<Self>,
2776 encoder: &mut ___E,
2777 out: &mut ::core::mem::MaybeUninit<
2778 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2779 >,
2780 _: (),
2781 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2782 if let Some(inner) = this {
2783 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2784 ::fidl_next::wire::Box::encode_present(out);
2785 } else {
2786 ::fidl_next::wire::Box::encode_absent(out);
2787 }
2788
2789 Ok(())
2790 }
2791 }
2792
2793 impl ::fidl_next::FromWire<crate::wire::DeviceInfo> for DeviceInfo {
2794 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DeviceInfo, Self> = unsafe {
2795 ::fidl_next::CopyOptimization::enable_if(
2796 true
2797
2798 && <
2799 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2800 >::COPY_OPTIMIZATION.is_enabled()
2801
2802 && <
2803 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2804 >::COPY_OPTIMIZATION.is_enabled()
2805
2806 && <
2807 u8 as ::fidl_next::FromWire<u8>
2808 >::COPY_OPTIMIZATION.is_enabled()
2809
2810 && <
2811 u8 as ::fidl_next::FromWire<u8>
2812 >::COPY_OPTIMIZATION.is_enabled()
2813
2814 && <
2815 u8 as ::fidl_next::FromWire<u8>
2816 >::COPY_OPTIMIZATION.is_enabled()
2817
2818 && <
2819 u8 as ::fidl_next::FromWire<u8>
2820 >::COPY_OPTIMIZATION.is_enabled()
2821
2822 && <
2823 u8 as ::fidl_next::FromWire<u8>
2824 >::COPY_OPTIMIZATION.is_enabled()
2825
2826 && <
2827 u8 as ::fidl_next::FromWire<u8>
2828 >::COPY_OPTIMIZATION.is_enabled()
2829
2830 && <
2831 u8 as ::fidl_next::FromWire<u8>
2832 >::COPY_OPTIMIZATION.is_enabled()
2833
2834 && <
2835 crate::natural::Padding as ::fidl_next::FromWire<crate::wire::Padding>
2836 >::COPY_OPTIMIZATION.is_enabled()
2837
2838 )
2839 };
2840
2841 #[inline]
2842 fn from_wire(wire: crate::wire::DeviceInfo) -> Self {
2843 Self {
2844 vendor_id: ::fidl_next::FromWire::from_wire(wire.vendor_id),
2845
2846 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
2847
2848 base_class: ::fidl_next::FromWire::from_wire(wire.base_class),
2849
2850 sub_class: ::fidl_next::FromWire::from_wire(wire.sub_class),
2851
2852 program_interface: ::fidl_next::FromWire::from_wire(wire.program_interface),
2853
2854 revision_id: ::fidl_next::FromWire::from_wire(wire.revision_id),
2855
2856 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
2857
2858 dev_id: ::fidl_next::FromWire::from_wire(wire.dev_id),
2859
2860 func_id: ::fidl_next::FromWire::from_wire(wire.func_id),
2861
2862 padding: ::fidl_next::FromWire::from_wire(wire.padding),
2863 }
2864 }
2865 }
2866
2867 impl ::fidl_next::FromWireRef<crate::wire::DeviceInfo> for DeviceInfo {
2868 #[inline]
2869 fn from_wire_ref(wire: &crate::wire::DeviceInfo) -> Self {
2870 Self {
2871 vendor_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.vendor_id),
2872
2873 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
2874
2875 base_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_class),
2876
2877 sub_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.sub_class),
2878
2879 program_interface: ::fidl_next::FromWireRef::from_wire_ref(&wire.program_interface),
2880
2881 revision_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.revision_id),
2882
2883 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
2884
2885 dev_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dev_id),
2886
2887 func_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.func_id),
2888
2889 padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
2890 }
2891 }
2892 }
2893
2894 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2895 #[repr(C)]
2896 pub struct DeviceGetDeviceInfoResponse {
2897 pub info: crate::natural::DeviceInfo,
2898 }
2899
2900 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
2901 for DeviceGetDeviceInfoResponse
2902 where
2903 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2904 {
2905 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2906 Self,
2907 crate::wire::DeviceGetDeviceInfoResponse,
2908 > = unsafe {
2909 ::fidl_next::CopyOptimization::enable_if(
2910 true && <crate::natural::DeviceInfo as ::fidl_next::Encode<
2911 crate::wire::DeviceInfo,
2912 ___E,
2913 >>::COPY_OPTIMIZATION
2914 .is_enabled(),
2915 )
2916 };
2917
2918 #[inline]
2919 fn encode(
2920 self,
2921 encoder_: &mut ___E,
2922 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
2923 _: (),
2924 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2925 ::fidl_next::munge! {
2926 let crate::wire::DeviceGetDeviceInfoResponse {
2927 info,
2928
2929 } = out_;
2930 }
2931
2932 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
2933
2934 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
2935
2936 Ok(())
2937 }
2938 }
2939
2940 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
2941 for &'a DeviceGetDeviceInfoResponse
2942 where
2943 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2944 {
2945 #[inline]
2946 fn encode(
2947 self,
2948 encoder_: &mut ___E,
2949 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
2950 _: (),
2951 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2952 ::fidl_next::munge! {
2953 let crate::wire::DeviceGetDeviceInfoResponse {
2954 info,
2955
2956 } = out_;
2957 }
2958
2959 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
2960
2961 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
2962
2963 Ok(())
2964 }
2965 }
2966
2967 unsafe impl<___E>
2968 ::fidl_next::EncodeOption<
2969 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2970 ___E,
2971 > for DeviceGetDeviceInfoResponse
2972 where
2973 ___E: ::fidl_next::Encoder + ?Sized,
2974 DeviceGetDeviceInfoResponse:
2975 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
2976 {
2977 #[inline]
2978 fn encode_option(
2979 this: ::core::option::Option<Self>,
2980 encoder: &mut ___E,
2981 out: &mut ::core::mem::MaybeUninit<
2982 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2983 >,
2984 _: (),
2985 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2986 if let Some(inner) = this {
2987 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2988 ::fidl_next::wire::Box::encode_present(out);
2989 } else {
2990 ::fidl_next::wire::Box::encode_absent(out);
2991 }
2992
2993 Ok(())
2994 }
2995 }
2996
2997 unsafe impl<'a, ___E>
2998 ::fidl_next::EncodeOption<
2999 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3000 ___E,
3001 > for &'a DeviceGetDeviceInfoResponse
3002 where
3003 ___E: ::fidl_next::Encoder + ?Sized,
3004 &'a DeviceGetDeviceInfoResponse:
3005 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
3006 {
3007 #[inline]
3008 fn encode_option(
3009 this: ::core::option::Option<Self>,
3010 encoder: &mut ___E,
3011 out: &mut ::core::mem::MaybeUninit<
3012 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3013 >,
3014 _: (),
3015 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3016 if let Some(inner) = this {
3017 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3018 ::fidl_next::wire::Box::encode_present(out);
3019 } else {
3020 ::fidl_next::wire::Box::encode_absent(out);
3021 }
3022
3023 Ok(())
3024 }
3025 }
3026
3027 impl ::fidl_next::FromWire<crate::wire::DeviceGetDeviceInfoResponse>
3028 for DeviceGetDeviceInfoResponse
3029 {
3030 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3031 crate::wire::DeviceGetDeviceInfoResponse,
3032 Self,
3033 > = unsafe {
3034 ::fidl_next::CopyOptimization::enable_if(
3035 true && <crate::natural::DeviceInfo as ::fidl_next::FromWire<
3036 crate::wire::DeviceInfo,
3037 >>::COPY_OPTIMIZATION
3038 .is_enabled(),
3039 )
3040 };
3041
3042 #[inline]
3043 fn from_wire(wire: crate::wire::DeviceGetDeviceInfoResponse) -> Self {
3044 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
3045 }
3046 }
3047
3048 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetDeviceInfoResponse>
3049 for DeviceGetDeviceInfoResponse
3050 {
3051 #[inline]
3052 fn from_wire_ref(wire: &crate::wire::DeviceGetDeviceInfoResponse) -> Self {
3053 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
3054 }
3055 }
3056
3057 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3058 #[repr(C)]
3059 pub struct DeviceGetBarRequest {
3060 pub bar_id: u32,
3061 }
3062
3063 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
3064 for DeviceGetBarRequest
3065 where
3066 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3067 {
3068 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3069 Self,
3070 crate::wire::DeviceGetBarRequest,
3071 > = unsafe {
3072 ::fidl_next::CopyOptimization::enable_if(
3073 true
3074
3075 && <
3076 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3077 >::COPY_OPTIMIZATION.is_enabled()
3078
3079 )
3080 };
3081
3082 #[inline]
3083 fn encode(
3084 self,
3085 encoder_: &mut ___E,
3086 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
3087 _: (),
3088 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3089 ::fidl_next::munge! {
3090 let crate::wire::DeviceGetBarRequest {
3091 bar_id,
3092
3093 } = out_;
3094 }
3095
3096 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
3097
3098 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
3099
3100 Ok(())
3101 }
3102 }
3103
3104 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
3105 for &'a DeviceGetBarRequest
3106 where
3107 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3108 {
3109 #[inline]
3110 fn encode(
3111 self,
3112 encoder_: &mut ___E,
3113 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::DeviceGetBarRequest {
3118 bar_id,
3119
3120 } = out_;
3121 }
3122
3123 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
3124
3125 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
3126
3127 Ok(())
3128 }
3129 }
3130
3131 unsafe impl<___E>
3132 ::fidl_next::EncodeOption<
3133 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3134 ___E,
3135 > for DeviceGetBarRequest
3136 where
3137 ___E: ::fidl_next::Encoder + ?Sized,
3138 DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3139 {
3140 #[inline]
3141 fn encode_option(
3142 this: ::core::option::Option<Self>,
3143 encoder: &mut ___E,
3144 out: &mut ::core::mem::MaybeUninit<
3145 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3146 >,
3147 _: (),
3148 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3149 if let Some(inner) = this {
3150 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3151 ::fidl_next::wire::Box::encode_present(out);
3152 } else {
3153 ::fidl_next::wire::Box::encode_absent(out);
3154 }
3155
3156 Ok(())
3157 }
3158 }
3159
3160 unsafe impl<'a, ___E>
3161 ::fidl_next::EncodeOption<
3162 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3163 ___E,
3164 > for &'a DeviceGetBarRequest
3165 where
3166 ___E: ::fidl_next::Encoder + ?Sized,
3167 &'a DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3168 {
3169 #[inline]
3170 fn encode_option(
3171 this: ::core::option::Option<Self>,
3172 encoder: &mut ___E,
3173 out: &mut ::core::mem::MaybeUninit<
3174 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3175 >,
3176 _: (),
3177 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3178 if let Some(inner) = this {
3179 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3180 ::fidl_next::wire::Box::encode_present(out);
3181 } else {
3182 ::fidl_next::wire::Box::encode_absent(out);
3183 }
3184
3185 Ok(())
3186 }
3187 }
3188
3189 impl ::fidl_next::FromWire<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3190 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3191 crate::wire::DeviceGetBarRequest,
3192 Self,
3193 > = unsafe {
3194 ::fidl_next::CopyOptimization::enable_if(
3195 true
3196 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3197 .is_enabled(),
3198 )
3199 };
3200
3201 #[inline]
3202 fn from_wire(wire: crate::wire::DeviceGetBarRequest) -> Self {
3203 Self { bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id) }
3204 }
3205 }
3206
3207 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3208 #[inline]
3209 fn from_wire_ref(wire: &crate::wire::DeviceGetBarRequest) -> Self {
3210 Self { bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id) }
3211 }
3212 }
3213
3214 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3215 #[repr(C)]
3216 pub struct DeviceSetBusMasteringRequest {
3217 pub enabled: bool,
3218 }
3219
3220 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3221 for DeviceSetBusMasteringRequest
3222 where
3223 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3224 {
3225 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3226 Self,
3227 crate::wire::DeviceSetBusMasteringRequest,
3228 > = unsafe {
3229 ::fidl_next::CopyOptimization::enable_if(
3230 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
3231 )
3232 };
3233
3234 #[inline]
3235 fn encode(
3236 self,
3237 encoder_: &mut ___E,
3238 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3239 _: (),
3240 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3241 ::fidl_next::munge! {
3242 let crate::wire::DeviceSetBusMasteringRequest {
3243 enabled,
3244
3245 } = out_;
3246 }
3247
3248 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
3249
3250 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3251
3252 Ok(())
3253 }
3254 }
3255
3256 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3257 for &'a DeviceSetBusMasteringRequest
3258 where
3259 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3260 {
3261 #[inline]
3262 fn encode(
3263 self,
3264 encoder_: &mut ___E,
3265 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3266 _: (),
3267 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3268 ::fidl_next::munge! {
3269 let crate::wire::DeviceSetBusMasteringRequest {
3270 enabled,
3271
3272 } = out_;
3273 }
3274
3275 ::fidl_next::Encode::encode(&self.enabled, encoder_, enabled, ())?;
3276
3277 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3278
3279 Ok(())
3280 }
3281 }
3282
3283 unsafe impl<___E>
3284 ::fidl_next::EncodeOption<
3285 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3286 ___E,
3287 > for DeviceSetBusMasteringRequest
3288 where
3289 ___E: ::fidl_next::Encoder + ?Sized,
3290 DeviceSetBusMasteringRequest:
3291 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3292 {
3293 #[inline]
3294 fn encode_option(
3295 this: ::core::option::Option<Self>,
3296 encoder: &mut ___E,
3297 out: &mut ::core::mem::MaybeUninit<
3298 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3299 >,
3300 _: (),
3301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3302 if let Some(inner) = this {
3303 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3304 ::fidl_next::wire::Box::encode_present(out);
3305 } else {
3306 ::fidl_next::wire::Box::encode_absent(out);
3307 }
3308
3309 Ok(())
3310 }
3311 }
3312
3313 unsafe impl<'a, ___E>
3314 ::fidl_next::EncodeOption<
3315 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3316 ___E,
3317 > for &'a DeviceSetBusMasteringRequest
3318 where
3319 ___E: ::fidl_next::Encoder + ?Sized,
3320 &'a DeviceSetBusMasteringRequest:
3321 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3322 {
3323 #[inline]
3324 fn encode_option(
3325 this: ::core::option::Option<Self>,
3326 encoder: &mut ___E,
3327 out: &mut ::core::mem::MaybeUninit<
3328 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3329 >,
3330 _: (),
3331 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3332 if let Some(inner) = this {
3333 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3334 ::fidl_next::wire::Box::encode_present(out);
3335 } else {
3336 ::fidl_next::wire::Box::encode_absent(out);
3337 }
3338
3339 Ok(())
3340 }
3341 }
3342
3343 impl ::fidl_next::FromWire<crate::wire::DeviceSetBusMasteringRequest>
3344 for DeviceSetBusMasteringRequest
3345 {
3346 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3347 crate::wire::DeviceSetBusMasteringRequest,
3348 Self,
3349 > = unsafe {
3350 ::fidl_next::CopyOptimization::enable_if(
3351 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
3352 )
3353 };
3354
3355 #[inline]
3356 fn from_wire(wire: crate::wire::DeviceSetBusMasteringRequest) -> Self {
3357 Self { enabled: ::fidl_next::FromWire::from_wire(wire.enabled) }
3358 }
3359 }
3360
3361 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetBusMasteringRequest>
3362 for DeviceSetBusMasteringRequest
3363 {
3364 #[inline]
3365 fn from_wire_ref(wire: &crate::wire::DeviceSetBusMasteringRequest) -> Self {
3366 Self { enabled: ::fidl_next::FromWireRef::from_wire_ref(&wire.enabled) }
3367 }
3368 }
3369
3370 pub type DeviceSetBusMasteringResponse = ();
3371
3372 pub type DeviceResetDeviceResponse = ();
3373
3374 pub type DeviceAckInterruptResponse = ();
3375
3376 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3377 #[repr(C)]
3378 pub struct DeviceMapInterruptRequest {
3379 pub which_irq: u32,
3380 }
3381
3382 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3383 for DeviceMapInterruptRequest
3384 where
3385 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3386 {
3387 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3388 Self,
3389 crate::wire::DeviceMapInterruptRequest,
3390 > = unsafe {
3391 ::fidl_next::CopyOptimization::enable_if(
3392 true
3393
3394 && <
3395 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3396 >::COPY_OPTIMIZATION.is_enabled()
3397
3398 )
3399 };
3400
3401 #[inline]
3402 fn encode(
3403 self,
3404 encoder_: &mut ___E,
3405 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3406 _: (),
3407 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3408 ::fidl_next::munge! {
3409 let crate::wire::DeviceMapInterruptRequest {
3410 which_irq,
3411
3412 } = out_;
3413 }
3414
3415 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
3416
3417 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3418
3419 Ok(())
3420 }
3421 }
3422
3423 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3424 for &'a DeviceMapInterruptRequest
3425 where
3426 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3427 {
3428 #[inline]
3429 fn encode(
3430 self,
3431 encoder_: &mut ___E,
3432 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3433 _: (),
3434 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3435 ::fidl_next::munge! {
3436 let crate::wire::DeviceMapInterruptRequest {
3437 which_irq,
3438
3439 } = out_;
3440 }
3441
3442 ::fidl_next::Encode::encode(&self.which_irq, encoder_, which_irq, ())?;
3443
3444 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3445
3446 Ok(())
3447 }
3448 }
3449
3450 unsafe impl<___E>
3451 ::fidl_next::EncodeOption<
3452 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3453 ___E,
3454 > for DeviceMapInterruptRequest
3455 where
3456 ___E: ::fidl_next::Encoder + ?Sized,
3457 DeviceMapInterruptRequest:
3458 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3459 {
3460 #[inline]
3461 fn encode_option(
3462 this: ::core::option::Option<Self>,
3463 encoder: &mut ___E,
3464 out: &mut ::core::mem::MaybeUninit<
3465 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3466 >,
3467 _: (),
3468 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3469 if let Some(inner) = this {
3470 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3471 ::fidl_next::wire::Box::encode_present(out);
3472 } else {
3473 ::fidl_next::wire::Box::encode_absent(out);
3474 }
3475
3476 Ok(())
3477 }
3478 }
3479
3480 unsafe impl<'a, ___E>
3481 ::fidl_next::EncodeOption<
3482 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3483 ___E,
3484 > for &'a DeviceMapInterruptRequest
3485 where
3486 ___E: ::fidl_next::Encoder + ?Sized,
3487 &'a DeviceMapInterruptRequest:
3488 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3489 {
3490 #[inline]
3491 fn encode_option(
3492 this: ::core::option::Option<Self>,
3493 encoder: &mut ___E,
3494 out: &mut ::core::mem::MaybeUninit<
3495 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3496 >,
3497 _: (),
3498 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3499 if let Some(inner) = this {
3500 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3501 ::fidl_next::wire::Box::encode_present(out);
3502 } else {
3503 ::fidl_next::wire::Box::encode_absent(out);
3504 }
3505
3506 Ok(())
3507 }
3508 }
3509
3510 impl ::fidl_next::FromWire<crate::wire::DeviceMapInterruptRequest> for DeviceMapInterruptRequest {
3511 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3512 crate::wire::DeviceMapInterruptRequest,
3513 Self,
3514 > = unsafe {
3515 ::fidl_next::CopyOptimization::enable_if(
3516 true
3517 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3518 .is_enabled(),
3519 )
3520 };
3521
3522 #[inline]
3523 fn from_wire(wire: crate::wire::DeviceMapInterruptRequest) -> Self {
3524 Self { which_irq: ::fidl_next::FromWire::from_wire(wire.which_irq) }
3525 }
3526 }
3527
3528 impl ::fidl_next::FromWireRef<crate::wire::DeviceMapInterruptRequest>
3529 for DeviceMapInterruptRequest
3530 {
3531 #[inline]
3532 fn from_wire_ref(wire: &crate::wire::DeviceMapInterruptRequest) -> Self {
3533 Self { which_irq: ::fidl_next::FromWireRef::from_wire_ref(&wire.which_irq) }
3534 }
3535 }
3536
3537 #[doc = " Returned by |GetInterruptModes|. Contains the number of interrupts supported\n by a given PCI device interrupt mode. 0 is returned for a mode if\n unsupported.\n"]
3538 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3539 #[repr(C)]
3540 pub struct InterruptModes {
3541 pub has_legacy: bool,
3542
3543 pub msi_count: u8,
3544
3545 pub msix_count: u16,
3546 }
3547
3548 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for InterruptModes
3549 where
3550 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3551 {
3552 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InterruptModes> = unsafe {
3553 ::fidl_next::CopyOptimization::enable_if(
3554 true
3555
3556 && <
3557 bool as ::fidl_next::Encode<bool, ___E>
3558 >::COPY_OPTIMIZATION.is_enabled()
3559
3560 && <
3561 u8 as ::fidl_next::Encode<u8, ___E>
3562 >::COPY_OPTIMIZATION.is_enabled()
3563
3564 && <
3565 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
3566 >::COPY_OPTIMIZATION.is_enabled()
3567
3568 )
3569 };
3570
3571 #[inline]
3572 fn encode(
3573 self,
3574 encoder_: &mut ___E,
3575 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3576 _: (),
3577 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3578 ::fidl_next::munge! {
3579 let crate::wire::InterruptModes {
3580 has_legacy,
3581 msi_count,
3582 msix_count,
3583
3584 } = out_;
3585 }
3586
3587 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
3588
3589 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3590
3591 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
3592
3593 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3594
3595 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
3596
3597 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3598
3599 Ok(())
3600 }
3601 }
3602
3603 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for &'a InterruptModes
3604 where
3605 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3606 {
3607 #[inline]
3608 fn encode(
3609 self,
3610 encoder_: &mut ___E,
3611 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3612 _: (),
3613 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3614 ::fidl_next::munge! {
3615 let crate::wire::InterruptModes {
3616 has_legacy,
3617 msi_count,
3618 msix_count,
3619
3620 } = out_;
3621 }
3622
3623 ::fidl_next::Encode::encode(&self.has_legacy, encoder_, has_legacy, ())?;
3624
3625 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3626
3627 ::fidl_next::Encode::encode(&self.msi_count, encoder_, msi_count, ())?;
3628
3629 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3630
3631 ::fidl_next::Encode::encode(&self.msix_count, encoder_, msix_count, ())?;
3632
3633 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3634
3635 Ok(())
3636 }
3637 }
3638
3639 unsafe impl<___E>
3640 ::fidl_next::EncodeOption<
3641 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3642 ___E,
3643 > for InterruptModes
3644 where
3645 ___E: ::fidl_next::Encoder + ?Sized,
3646 InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3647 {
3648 #[inline]
3649 fn encode_option(
3650 this: ::core::option::Option<Self>,
3651 encoder: &mut ___E,
3652 out: &mut ::core::mem::MaybeUninit<
3653 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3654 >,
3655 _: (),
3656 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3657 if let Some(inner) = this {
3658 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3659 ::fidl_next::wire::Box::encode_present(out);
3660 } else {
3661 ::fidl_next::wire::Box::encode_absent(out);
3662 }
3663
3664 Ok(())
3665 }
3666 }
3667
3668 unsafe impl<'a, ___E>
3669 ::fidl_next::EncodeOption<
3670 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3671 ___E,
3672 > for &'a InterruptModes
3673 where
3674 ___E: ::fidl_next::Encoder + ?Sized,
3675 &'a InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3676 {
3677 #[inline]
3678 fn encode_option(
3679 this: ::core::option::Option<Self>,
3680 encoder: &mut ___E,
3681 out: &mut ::core::mem::MaybeUninit<
3682 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3683 >,
3684 _: (),
3685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3686 if let Some(inner) = this {
3687 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3688 ::fidl_next::wire::Box::encode_present(out);
3689 } else {
3690 ::fidl_next::wire::Box::encode_absent(out);
3691 }
3692
3693 Ok(())
3694 }
3695 }
3696
3697 impl ::fidl_next::FromWire<crate::wire::InterruptModes> for InterruptModes {
3698 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InterruptModes, Self> = unsafe {
3699 ::fidl_next::CopyOptimization::enable_if(
3700 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled()
3701 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
3702 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
3703 .is_enabled(),
3704 )
3705 };
3706
3707 #[inline]
3708 fn from_wire(wire: crate::wire::InterruptModes) -> Self {
3709 Self {
3710 has_legacy: ::fidl_next::FromWire::from_wire(wire.has_legacy),
3711
3712 msi_count: ::fidl_next::FromWire::from_wire(wire.msi_count),
3713
3714 msix_count: ::fidl_next::FromWire::from_wire(wire.msix_count),
3715 }
3716 }
3717 }
3718
3719 impl ::fidl_next::FromWireRef<crate::wire::InterruptModes> for InterruptModes {
3720 #[inline]
3721 fn from_wire_ref(wire: &crate::wire::InterruptModes) -> Self {
3722 Self {
3723 has_legacy: ::fidl_next::FromWireRef::from_wire_ref(&wire.has_legacy),
3724
3725 msi_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msi_count),
3726
3727 msix_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msix_count),
3728 }
3729 }
3730 }
3731
3732 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3733 #[repr(C)]
3734 pub struct DeviceGetInterruptModesResponse {
3735 pub modes: crate::natural::InterruptModes,
3736 }
3737
3738 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3739 for DeviceGetInterruptModesResponse
3740 where
3741 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3742 {
3743 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3744 Self,
3745 crate::wire::DeviceGetInterruptModesResponse,
3746 > = unsafe {
3747 ::fidl_next::CopyOptimization::enable_if(
3748 true && <crate::natural::InterruptModes as ::fidl_next::Encode<
3749 crate::wire::InterruptModes,
3750 ___E,
3751 >>::COPY_OPTIMIZATION
3752 .is_enabled(),
3753 )
3754 };
3755
3756 #[inline]
3757 fn encode(
3758 self,
3759 encoder_: &mut ___E,
3760 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3761 _: (),
3762 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3763 ::fidl_next::munge! {
3764 let crate::wire::DeviceGetInterruptModesResponse {
3765 modes,
3766
3767 } = out_;
3768 }
3769
3770 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
3771
3772 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3773
3774 Ok(())
3775 }
3776 }
3777
3778 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3779 for &'a DeviceGetInterruptModesResponse
3780 where
3781 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3782 {
3783 #[inline]
3784 fn encode(
3785 self,
3786 encoder_: &mut ___E,
3787 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3788 _: (),
3789 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3790 ::fidl_next::munge! {
3791 let crate::wire::DeviceGetInterruptModesResponse {
3792 modes,
3793
3794 } = out_;
3795 }
3796
3797 ::fidl_next::Encode::encode(&self.modes, encoder_, modes, ())?;
3798
3799 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3800
3801 Ok(())
3802 }
3803 }
3804
3805 unsafe impl<___E>
3806 ::fidl_next::EncodeOption<
3807 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3808 ___E,
3809 > for DeviceGetInterruptModesResponse
3810 where
3811 ___E: ::fidl_next::Encoder + ?Sized,
3812 DeviceGetInterruptModesResponse:
3813 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
3814 {
3815 #[inline]
3816 fn encode_option(
3817 this: ::core::option::Option<Self>,
3818 encoder: &mut ___E,
3819 out: &mut ::core::mem::MaybeUninit<
3820 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3821 >,
3822 _: (),
3823 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3824 if let Some(inner) = this {
3825 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3826 ::fidl_next::wire::Box::encode_present(out);
3827 } else {
3828 ::fidl_next::wire::Box::encode_absent(out);
3829 }
3830
3831 Ok(())
3832 }
3833 }
3834
3835 unsafe impl<'a, ___E>
3836 ::fidl_next::EncodeOption<
3837 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3838 ___E,
3839 > for &'a DeviceGetInterruptModesResponse
3840 where
3841 ___E: ::fidl_next::Encoder + ?Sized,
3842 &'a DeviceGetInterruptModesResponse:
3843 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
3844 {
3845 #[inline]
3846 fn encode_option(
3847 this: ::core::option::Option<Self>,
3848 encoder: &mut ___E,
3849 out: &mut ::core::mem::MaybeUninit<
3850 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3851 >,
3852 _: (),
3853 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3854 if let Some(inner) = this {
3855 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3856 ::fidl_next::wire::Box::encode_present(out);
3857 } else {
3858 ::fidl_next::wire::Box::encode_absent(out);
3859 }
3860
3861 Ok(())
3862 }
3863 }
3864
3865 impl ::fidl_next::FromWire<crate::wire::DeviceGetInterruptModesResponse>
3866 for DeviceGetInterruptModesResponse
3867 {
3868 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3869 crate::wire::DeviceGetInterruptModesResponse,
3870 Self,
3871 > = unsafe {
3872 ::fidl_next::CopyOptimization::enable_if(
3873 true && <crate::natural::InterruptModes as ::fidl_next::FromWire<
3874 crate::wire::InterruptModes,
3875 >>::COPY_OPTIMIZATION
3876 .is_enabled(),
3877 )
3878 };
3879
3880 #[inline]
3881 fn from_wire(wire: crate::wire::DeviceGetInterruptModesResponse) -> Self {
3882 Self { modes: ::fidl_next::FromWire::from_wire(wire.modes) }
3883 }
3884 }
3885
3886 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetInterruptModesResponse>
3887 for DeviceGetInterruptModesResponse
3888 {
3889 #[inline]
3890 fn from_wire_ref(wire: &crate::wire::DeviceGetInterruptModesResponse) -> Self {
3891 Self { modes: ::fidl_next::FromWireRef::from_wire_ref(&wire.modes) }
3892 }
3893 }
3894
3895 pub type DeviceSetInterruptModeResponse = ();
3896
3897 #[doc = " An offset from the beginning of a device\'s PCIe configuration space. [0, 0x800) is valid.\n"]
3898 pub type ExtendedConfigOffset = u16;
3899
3900 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3901 #[repr(C)]
3902 pub struct DeviceReadConfig8Request {
3903 pub offset: u16,
3904 }
3905
3906 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
3907 for DeviceReadConfig8Request
3908 where
3909 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3910 {
3911 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3912 Self,
3913 crate::wire::DeviceReadConfig8Request,
3914 > = unsafe {
3915 ::fidl_next::CopyOptimization::enable_if(
3916 true
3917
3918 && <
3919 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
3920 >::COPY_OPTIMIZATION.is_enabled()
3921
3922 )
3923 };
3924
3925 #[inline]
3926 fn encode(
3927 self,
3928 encoder_: &mut ___E,
3929 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
3930 _: (),
3931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3932 ::fidl_next::munge! {
3933 let crate::wire::DeviceReadConfig8Request {
3934 offset,
3935
3936 } = out_;
3937 }
3938
3939 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
3940
3941 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
3942
3943 Ok(())
3944 }
3945 }
3946
3947 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
3948 for &'a DeviceReadConfig8Request
3949 where
3950 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3951 {
3952 #[inline]
3953 fn encode(
3954 self,
3955 encoder_: &mut ___E,
3956 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
3957 _: (),
3958 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3959 ::fidl_next::munge! {
3960 let crate::wire::DeviceReadConfig8Request {
3961 offset,
3962
3963 } = out_;
3964 }
3965
3966 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
3967
3968 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
3969
3970 Ok(())
3971 }
3972 }
3973
3974 unsafe impl<___E>
3975 ::fidl_next::EncodeOption<
3976 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3977 ___E,
3978 > for DeviceReadConfig8Request
3979 where
3980 ___E: ::fidl_next::Encoder + ?Sized,
3981 DeviceReadConfig8Request: ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
3982 {
3983 #[inline]
3984 fn encode_option(
3985 this: ::core::option::Option<Self>,
3986 encoder: &mut ___E,
3987 out: &mut ::core::mem::MaybeUninit<
3988 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3989 >,
3990 _: (),
3991 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3992 if let Some(inner) = this {
3993 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3994 ::fidl_next::wire::Box::encode_present(out);
3995 } else {
3996 ::fidl_next::wire::Box::encode_absent(out);
3997 }
3998
3999 Ok(())
4000 }
4001 }
4002
4003 unsafe impl<'a, ___E>
4004 ::fidl_next::EncodeOption<
4005 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4006 ___E,
4007 > for &'a DeviceReadConfig8Request
4008 where
4009 ___E: ::fidl_next::Encoder + ?Sized,
4010 &'a DeviceReadConfig8Request:
4011 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
4012 {
4013 #[inline]
4014 fn encode_option(
4015 this: ::core::option::Option<Self>,
4016 encoder: &mut ___E,
4017 out: &mut ::core::mem::MaybeUninit<
4018 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4019 >,
4020 _: (),
4021 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4022 if let Some(inner) = this {
4023 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4024 ::fidl_next::wire::Box::encode_present(out);
4025 } else {
4026 ::fidl_next::wire::Box::encode_absent(out);
4027 }
4028
4029 Ok(())
4030 }
4031 }
4032
4033 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
4034 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4035 crate::wire::DeviceReadConfig8Request,
4036 Self,
4037 > = unsafe {
4038 ::fidl_next::CopyOptimization::enable_if(
4039 true
4040 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4041 .is_enabled(),
4042 )
4043 };
4044
4045 #[inline]
4046 fn from_wire(wire: crate::wire::DeviceReadConfig8Request) -> Self {
4047 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4048 }
4049 }
4050
4051 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
4052 #[inline]
4053 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Request) -> Self {
4054 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4055 }
4056 }
4057
4058 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4059 #[repr(C)]
4060 pub struct DeviceReadConfig8Response {
4061 pub value: u8,
4062 }
4063
4064 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
4065 for DeviceReadConfig8Response
4066 where
4067 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4068 {
4069 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4070 Self,
4071 crate::wire::DeviceReadConfig8Response,
4072 > = unsafe {
4073 ::fidl_next::CopyOptimization::enable_if(
4074 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
4075 )
4076 };
4077
4078 #[inline]
4079 fn encode(
4080 self,
4081 encoder_: &mut ___E,
4082 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
4083 _: (),
4084 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4085 ::fidl_next::munge! {
4086 let crate::wire::DeviceReadConfig8Response {
4087 value,
4088
4089 } = out_;
4090 }
4091
4092 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4093
4094 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4095
4096 Ok(())
4097 }
4098 }
4099
4100 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
4101 for &'a DeviceReadConfig8Response
4102 where
4103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4104 {
4105 #[inline]
4106 fn encode(
4107 self,
4108 encoder_: &mut ___E,
4109 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
4110 _: (),
4111 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4112 ::fidl_next::munge! {
4113 let crate::wire::DeviceReadConfig8Response {
4114 value,
4115
4116 } = out_;
4117 }
4118
4119 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4120
4121 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4122
4123 Ok(())
4124 }
4125 }
4126
4127 unsafe impl<___E>
4128 ::fidl_next::EncodeOption<
4129 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4130 ___E,
4131 > for DeviceReadConfig8Response
4132 where
4133 ___E: ::fidl_next::Encoder + ?Sized,
4134 DeviceReadConfig8Response:
4135 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4136 {
4137 #[inline]
4138 fn encode_option(
4139 this: ::core::option::Option<Self>,
4140 encoder: &mut ___E,
4141 out: &mut ::core::mem::MaybeUninit<
4142 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4143 >,
4144 _: (),
4145 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4146 if let Some(inner) = this {
4147 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4148 ::fidl_next::wire::Box::encode_present(out);
4149 } else {
4150 ::fidl_next::wire::Box::encode_absent(out);
4151 }
4152
4153 Ok(())
4154 }
4155 }
4156
4157 unsafe impl<'a, ___E>
4158 ::fidl_next::EncodeOption<
4159 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4160 ___E,
4161 > for &'a DeviceReadConfig8Response
4162 where
4163 ___E: ::fidl_next::Encoder + ?Sized,
4164 &'a DeviceReadConfig8Response:
4165 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4166 {
4167 #[inline]
4168 fn encode_option(
4169 this: ::core::option::Option<Self>,
4170 encoder: &mut ___E,
4171 out: &mut ::core::mem::MaybeUninit<
4172 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4173 >,
4174 _: (),
4175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4176 if let Some(inner) = this {
4177 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4178 ::fidl_next::wire::Box::encode_present(out);
4179 } else {
4180 ::fidl_next::wire::Box::encode_absent(out);
4181 }
4182
4183 Ok(())
4184 }
4185 }
4186
4187 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Response> for DeviceReadConfig8Response {
4188 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4189 crate::wire::DeviceReadConfig8Response,
4190 Self,
4191 > = unsafe {
4192 ::fidl_next::CopyOptimization::enable_if(
4193 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
4194 )
4195 };
4196
4197 #[inline]
4198 fn from_wire(wire: crate::wire::DeviceReadConfig8Response) -> Self {
4199 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4200 }
4201 }
4202
4203 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Response>
4204 for DeviceReadConfig8Response
4205 {
4206 #[inline]
4207 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Response) -> Self {
4208 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4209 }
4210 }
4211
4212 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4213 #[repr(C)]
4214 pub struct DeviceReadConfig16Request {
4215 pub offset: u16,
4216 }
4217
4218 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4219 for DeviceReadConfig16Request
4220 where
4221 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4222 {
4223 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4224 Self,
4225 crate::wire::DeviceReadConfig16Request,
4226 > = unsafe {
4227 ::fidl_next::CopyOptimization::enable_if(
4228 true
4229
4230 && <
4231 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4232 >::COPY_OPTIMIZATION.is_enabled()
4233
4234 )
4235 };
4236
4237 #[inline]
4238 fn encode(
4239 self,
4240 encoder_: &mut ___E,
4241 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4242 _: (),
4243 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4244 ::fidl_next::munge! {
4245 let crate::wire::DeviceReadConfig16Request {
4246 offset,
4247
4248 } = out_;
4249 }
4250
4251 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4252
4253 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4254
4255 Ok(())
4256 }
4257 }
4258
4259 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4260 for &'a DeviceReadConfig16Request
4261 where
4262 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4263 {
4264 #[inline]
4265 fn encode(
4266 self,
4267 encoder_: &mut ___E,
4268 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4269 _: (),
4270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4271 ::fidl_next::munge! {
4272 let crate::wire::DeviceReadConfig16Request {
4273 offset,
4274
4275 } = out_;
4276 }
4277
4278 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4279
4280 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4281
4282 Ok(())
4283 }
4284 }
4285
4286 unsafe impl<___E>
4287 ::fidl_next::EncodeOption<
4288 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4289 ___E,
4290 > for DeviceReadConfig16Request
4291 where
4292 ___E: ::fidl_next::Encoder + ?Sized,
4293 DeviceReadConfig16Request:
4294 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4295 {
4296 #[inline]
4297 fn encode_option(
4298 this: ::core::option::Option<Self>,
4299 encoder: &mut ___E,
4300 out: &mut ::core::mem::MaybeUninit<
4301 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4302 >,
4303 _: (),
4304 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4305 if let Some(inner) = this {
4306 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4307 ::fidl_next::wire::Box::encode_present(out);
4308 } else {
4309 ::fidl_next::wire::Box::encode_absent(out);
4310 }
4311
4312 Ok(())
4313 }
4314 }
4315
4316 unsafe impl<'a, ___E>
4317 ::fidl_next::EncodeOption<
4318 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4319 ___E,
4320 > for &'a DeviceReadConfig16Request
4321 where
4322 ___E: ::fidl_next::Encoder + ?Sized,
4323 &'a DeviceReadConfig16Request:
4324 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4325 {
4326 #[inline]
4327 fn encode_option(
4328 this: ::core::option::Option<Self>,
4329 encoder: &mut ___E,
4330 out: &mut ::core::mem::MaybeUninit<
4331 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4332 >,
4333 _: (),
4334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4335 if let Some(inner) = this {
4336 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4337 ::fidl_next::wire::Box::encode_present(out);
4338 } else {
4339 ::fidl_next::wire::Box::encode_absent(out);
4340 }
4341
4342 Ok(())
4343 }
4344 }
4345
4346 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Request> for DeviceReadConfig16Request {
4347 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4348 crate::wire::DeviceReadConfig16Request,
4349 Self,
4350 > = unsafe {
4351 ::fidl_next::CopyOptimization::enable_if(
4352 true
4353 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4354 .is_enabled(),
4355 )
4356 };
4357
4358 #[inline]
4359 fn from_wire(wire: crate::wire::DeviceReadConfig16Request) -> Self {
4360 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4361 }
4362 }
4363
4364 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Request>
4365 for DeviceReadConfig16Request
4366 {
4367 #[inline]
4368 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Request) -> Self {
4369 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4370 }
4371 }
4372
4373 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4374 #[repr(C)]
4375 pub struct DeviceReadConfig16Response {
4376 pub value: u16,
4377 }
4378
4379 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4380 for DeviceReadConfig16Response
4381 where
4382 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4383 {
4384 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4385 Self,
4386 crate::wire::DeviceReadConfig16Response,
4387 > = unsafe {
4388 ::fidl_next::CopyOptimization::enable_if(
4389 true
4390
4391 && <
4392 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4393 >::COPY_OPTIMIZATION.is_enabled()
4394
4395 )
4396 };
4397
4398 #[inline]
4399 fn encode(
4400 self,
4401 encoder_: &mut ___E,
4402 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4403 _: (),
4404 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4405 ::fidl_next::munge! {
4406 let crate::wire::DeviceReadConfig16Response {
4407 value,
4408
4409 } = out_;
4410 }
4411
4412 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4413
4414 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4415
4416 Ok(())
4417 }
4418 }
4419
4420 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4421 for &'a DeviceReadConfig16Response
4422 where
4423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4424 {
4425 #[inline]
4426 fn encode(
4427 self,
4428 encoder_: &mut ___E,
4429 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4430 _: (),
4431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4432 ::fidl_next::munge! {
4433 let crate::wire::DeviceReadConfig16Response {
4434 value,
4435
4436 } = out_;
4437 }
4438
4439 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4440
4441 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4442
4443 Ok(())
4444 }
4445 }
4446
4447 unsafe impl<___E>
4448 ::fidl_next::EncodeOption<
4449 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4450 ___E,
4451 > for DeviceReadConfig16Response
4452 where
4453 ___E: ::fidl_next::Encoder + ?Sized,
4454 DeviceReadConfig16Response:
4455 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4456 {
4457 #[inline]
4458 fn encode_option(
4459 this: ::core::option::Option<Self>,
4460 encoder: &mut ___E,
4461 out: &mut ::core::mem::MaybeUninit<
4462 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4463 >,
4464 _: (),
4465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4466 if let Some(inner) = this {
4467 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4468 ::fidl_next::wire::Box::encode_present(out);
4469 } else {
4470 ::fidl_next::wire::Box::encode_absent(out);
4471 }
4472
4473 Ok(())
4474 }
4475 }
4476
4477 unsafe impl<'a, ___E>
4478 ::fidl_next::EncodeOption<
4479 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4480 ___E,
4481 > for &'a DeviceReadConfig16Response
4482 where
4483 ___E: ::fidl_next::Encoder + ?Sized,
4484 &'a DeviceReadConfig16Response:
4485 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4486 {
4487 #[inline]
4488 fn encode_option(
4489 this: ::core::option::Option<Self>,
4490 encoder: &mut ___E,
4491 out: &mut ::core::mem::MaybeUninit<
4492 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4493 >,
4494 _: (),
4495 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4496 if let Some(inner) = this {
4497 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4498 ::fidl_next::wire::Box::encode_present(out);
4499 } else {
4500 ::fidl_next::wire::Box::encode_absent(out);
4501 }
4502
4503 Ok(())
4504 }
4505 }
4506
4507 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Response> for DeviceReadConfig16Response {
4508 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4509 crate::wire::DeviceReadConfig16Response,
4510 Self,
4511 > = unsafe {
4512 ::fidl_next::CopyOptimization::enable_if(
4513 true
4514 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4515 .is_enabled(),
4516 )
4517 };
4518
4519 #[inline]
4520 fn from_wire(wire: crate::wire::DeviceReadConfig16Response) -> Self {
4521 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4522 }
4523 }
4524
4525 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Response>
4526 for DeviceReadConfig16Response
4527 {
4528 #[inline]
4529 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Response) -> Self {
4530 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4531 }
4532 }
4533
4534 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4535 #[repr(C)]
4536 pub struct DeviceReadConfig32Request {
4537 pub offset: u16,
4538 }
4539
4540 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
4541 for DeviceReadConfig32Request
4542 where
4543 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4544 {
4545 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4546 Self,
4547 crate::wire::DeviceReadConfig32Request,
4548 > = unsafe {
4549 ::fidl_next::CopyOptimization::enable_if(
4550 true
4551
4552 && <
4553 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4554 >::COPY_OPTIMIZATION.is_enabled()
4555
4556 )
4557 };
4558
4559 #[inline]
4560 fn encode(
4561 self,
4562 encoder_: &mut ___E,
4563 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
4564 _: (),
4565 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4566 ::fidl_next::munge! {
4567 let crate::wire::DeviceReadConfig32Request {
4568 offset,
4569
4570 } = out_;
4571 }
4572
4573 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4574
4575 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4576
4577 Ok(())
4578 }
4579 }
4580
4581 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
4582 for &'a DeviceReadConfig32Request
4583 where
4584 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4585 {
4586 #[inline]
4587 fn encode(
4588 self,
4589 encoder_: &mut ___E,
4590 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
4591 _: (),
4592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4593 ::fidl_next::munge! {
4594 let crate::wire::DeviceReadConfig32Request {
4595 offset,
4596
4597 } = out_;
4598 }
4599
4600 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4601
4602 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4603
4604 Ok(())
4605 }
4606 }
4607
4608 unsafe impl<___E>
4609 ::fidl_next::EncodeOption<
4610 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4611 ___E,
4612 > for DeviceReadConfig32Request
4613 where
4614 ___E: ::fidl_next::Encoder + ?Sized,
4615 DeviceReadConfig32Request:
4616 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
4617 {
4618 #[inline]
4619 fn encode_option(
4620 this: ::core::option::Option<Self>,
4621 encoder: &mut ___E,
4622 out: &mut ::core::mem::MaybeUninit<
4623 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4624 >,
4625 _: (),
4626 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4627 if let Some(inner) = this {
4628 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4629 ::fidl_next::wire::Box::encode_present(out);
4630 } else {
4631 ::fidl_next::wire::Box::encode_absent(out);
4632 }
4633
4634 Ok(())
4635 }
4636 }
4637
4638 unsafe impl<'a, ___E>
4639 ::fidl_next::EncodeOption<
4640 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4641 ___E,
4642 > for &'a DeviceReadConfig32Request
4643 where
4644 ___E: ::fidl_next::Encoder + ?Sized,
4645 &'a DeviceReadConfig32Request:
4646 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
4647 {
4648 #[inline]
4649 fn encode_option(
4650 this: ::core::option::Option<Self>,
4651 encoder: &mut ___E,
4652 out: &mut ::core::mem::MaybeUninit<
4653 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4654 >,
4655 _: (),
4656 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4657 if let Some(inner) = this {
4658 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4659 ::fidl_next::wire::Box::encode_present(out);
4660 } else {
4661 ::fidl_next::wire::Box::encode_absent(out);
4662 }
4663
4664 Ok(())
4665 }
4666 }
4667
4668 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Request> for DeviceReadConfig32Request {
4669 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4670 crate::wire::DeviceReadConfig32Request,
4671 Self,
4672 > = unsafe {
4673 ::fidl_next::CopyOptimization::enable_if(
4674 true
4675 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4676 .is_enabled(),
4677 )
4678 };
4679
4680 #[inline]
4681 fn from_wire(wire: crate::wire::DeviceReadConfig32Request) -> Self {
4682 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4683 }
4684 }
4685
4686 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Request>
4687 for DeviceReadConfig32Request
4688 {
4689 #[inline]
4690 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Request) -> Self {
4691 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4692 }
4693 }
4694
4695 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4696 #[repr(C)]
4697 pub struct DeviceReadConfig32Response {
4698 pub value: u32,
4699 }
4700
4701 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
4702 for DeviceReadConfig32Response
4703 where
4704 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4705 {
4706 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4707 Self,
4708 crate::wire::DeviceReadConfig32Response,
4709 > = unsafe {
4710 ::fidl_next::CopyOptimization::enable_if(
4711 true
4712
4713 && <
4714 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
4715 >::COPY_OPTIMIZATION.is_enabled()
4716
4717 )
4718 };
4719
4720 #[inline]
4721 fn encode(
4722 self,
4723 encoder_: &mut ___E,
4724 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
4725 _: (),
4726 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4727 ::fidl_next::munge! {
4728 let crate::wire::DeviceReadConfig32Response {
4729 value,
4730
4731 } = out_;
4732 }
4733
4734 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4735
4736 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4737
4738 Ok(())
4739 }
4740 }
4741
4742 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
4743 for &'a DeviceReadConfig32Response
4744 where
4745 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4746 {
4747 #[inline]
4748 fn encode(
4749 self,
4750 encoder_: &mut ___E,
4751 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
4752 _: (),
4753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4754 ::fidl_next::munge! {
4755 let crate::wire::DeviceReadConfig32Response {
4756 value,
4757
4758 } = out_;
4759 }
4760
4761 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4762
4763 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4764
4765 Ok(())
4766 }
4767 }
4768
4769 unsafe impl<___E>
4770 ::fidl_next::EncodeOption<
4771 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4772 ___E,
4773 > for DeviceReadConfig32Response
4774 where
4775 ___E: ::fidl_next::Encoder + ?Sized,
4776 DeviceReadConfig32Response:
4777 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
4778 {
4779 #[inline]
4780 fn encode_option(
4781 this: ::core::option::Option<Self>,
4782 encoder: &mut ___E,
4783 out: &mut ::core::mem::MaybeUninit<
4784 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4785 >,
4786 _: (),
4787 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4788 if let Some(inner) = this {
4789 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4790 ::fidl_next::wire::Box::encode_present(out);
4791 } else {
4792 ::fidl_next::wire::Box::encode_absent(out);
4793 }
4794
4795 Ok(())
4796 }
4797 }
4798
4799 unsafe impl<'a, ___E>
4800 ::fidl_next::EncodeOption<
4801 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4802 ___E,
4803 > for &'a DeviceReadConfig32Response
4804 where
4805 ___E: ::fidl_next::Encoder + ?Sized,
4806 &'a DeviceReadConfig32Response:
4807 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
4808 {
4809 #[inline]
4810 fn encode_option(
4811 this: ::core::option::Option<Self>,
4812 encoder: &mut ___E,
4813 out: &mut ::core::mem::MaybeUninit<
4814 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4815 >,
4816 _: (),
4817 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4818 if let Some(inner) = this {
4819 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4820 ::fidl_next::wire::Box::encode_present(out);
4821 } else {
4822 ::fidl_next::wire::Box::encode_absent(out);
4823 }
4824
4825 Ok(())
4826 }
4827 }
4828
4829 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Response> for DeviceReadConfig32Response {
4830 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4831 crate::wire::DeviceReadConfig32Response,
4832 Self,
4833 > = unsafe {
4834 ::fidl_next::CopyOptimization::enable_if(
4835 true
4836 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
4837 .is_enabled(),
4838 )
4839 };
4840
4841 #[inline]
4842 fn from_wire(wire: crate::wire::DeviceReadConfig32Response) -> Self {
4843 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4844 }
4845 }
4846
4847 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Response>
4848 for DeviceReadConfig32Response
4849 {
4850 #[inline]
4851 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Response) -> Self {
4852 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4853 }
4854 }
4855
4856 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4857 pub struct DeviceWriteConfig8Request {
4858 pub offset: u16,
4859
4860 pub value: u8,
4861 }
4862
4863 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
4864 for DeviceWriteConfig8Request
4865 where
4866 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4867 {
4868 #[inline]
4869 fn encode(
4870 self,
4871 encoder_: &mut ___E,
4872 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
4873 _: (),
4874 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4875 ::fidl_next::munge! {
4876 let crate::wire::DeviceWriteConfig8Request {
4877 offset,
4878 value,
4879
4880 } = out_;
4881 }
4882
4883 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4884
4885 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4886
4887 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4888
4889 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4890
4891 Ok(())
4892 }
4893 }
4894
4895 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
4896 for &'a DeviceWriteConfig8Request
4897 where
4898 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4899 {
4900 #[inline]
4901 fn encode(
4902 self,
4903 encoder_: &mut ___E,
4904 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
4905 _: (),
4906 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4907 ::fidl_next::munge! {
4908 let crate::wire::DeviceWriteConfig8Request {
4909 offset,
4910 value,
4911
4912 } = out_;
4913 }
4914
4915 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4916
4917 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4918
4919 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4920
4921 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4922
4923 Ok(())
4924 }
4925 }
4926
4927 unsafe impl<___E>
4928 ::fidl_next::EncodeOption<
4929 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4930 ___E,
4931 > for DeviceWriteConfig8Request
4932 where
4933 ___E: ::fidl_next::Encoder + ?Sized,
4934 DeviceWriteConfig8Request:
4935 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
4936 {
4937 #[inline]
4938 fn encode_option(
4939 this: ::core::option::Option<Self>,
4940 encoder: &mut ___E,
4941 out: &mut ::core::mem::MaybeUninit<
4942 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4943 >,
4944 _: (),
4945 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4946 if let Some(inner) = this {
4947 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4948 ::fidl_next::wire::Box::encode_present(out);
4949 } else {
4950 ::fidl_next::wire::Box::encode_absent(out);
4951 }
4952
4953 Ok(())
4954 }
4955 }
4956
4957 unsafe impl<'a, ___E>
4958 ::fidl_next::EncodeOption<
4959 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4960 ___E,
4961 > for &'a DeviceWriteConfig8Request
4962 where
4963 ___E: ::fidl_next::Encoder + ?Sized,
4964 &'a DeviceWriteConfig8Request:
4965 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
4966 {
4967 #[inline]
4968 fn encode_option(
4969 this: ::core::option::Option<Self>,
4970 encoder: &mut ___E,
4971 out: &mut ::core::mem::MaybeUninit<
4972 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4973 >,
4974 _: (),
4975 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4976 if let Some(inner) = this {
4977 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4978 ::fidl_next::wire::Box::encode_present(out);
4979 } else {
4980 ::fidl_next::wire::Box::encode_absent(out);
4981 }
4982
4983 Ok(())
4984 }
4985 }
4986
4987 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig8Request> for DeviceWriteConfig8Request {
4988 #[inline]
4989 fn from_wire(wire: crate::wire::DeviceWriteConfig8Request) -> Self {
4990 Self {
4991 offset: ::fidl_next::FromWire::from_wire(wire.offset),
4992
4993 value: ::fidl_next::FromWire::from_wire(wire.value),
4994 }
4995 }
4996 }
4997
4998 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig8Request>
4999 for DeviceWriteConfig8Request
5000 {
5001 #[inline]
5002 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig8Request) -> Self {
5003 Self {
5004 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5005
5006 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5007 }
5008 }
5009 }
5010
5011 pub type DeviceWriteConfig8Response = ();
5012
5013 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5014 #[repr(C)]
5015 pub struct DeviceWriteConfig16Request {
5016 pub offset: u16,
5017
5018 pub value: u16,
5019 }
5020
5021 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
5022 for DeviceWriteConfig16Request
5023 where
5024 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5025 {
5026 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5027 Self,
5028 crate::wire::DeviceWriteConfig16Request,
5029 > = unsafe {
5030 ::fidl_next::CopyOptimization::enable_if(
5031 true
5032
5033 && <
5034 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
5035 >::COPY_OPTIMIZATION.is_enabled()
5036
5037 && <
5038 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
5039 >::COPY_OPTIMIZATION.is_enabled()
5040
5041 )
5042 };
5043
5044 #[inline]
5045 fn encode(
5046 self,
5047 encoder_: &mut ___E,
5048 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
5049 _: (),
5050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5051 ::fidl_next::munge! {
5052 let crate::wire::DeviceWriteConfig16Request {
5053 offset,
5054 value,
5055
5056 } = out_;
5057 }
5058
5059 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5060
5061 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5062
5063 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5064
5065 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5066
5067 Ok(())
5068 }
5069 }
5070
5071 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
5072 for &'a DeviceWriteConfig16Request
5073 where
5074 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5075 {
5076 #[inline]
5077 fn encode(
5078 self,
5079 encoder_: &mut ___E,
5080 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
5081 _: (),
5082 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5083 ::fidl_next::munge! {
5084 let crate::wire::DeviceWriteConfig16Request {
5085 offset,
5086 value,
5087
5088 } = out_;
5089 }
5090
5091 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5092
5093 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5094
5095 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5096
5097 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5098
5099 Ok(())
5100 }
5101 }
5102
5103 unsafe impl<___E>
5104 ::fidl_next::EncodeOption<
5105 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5106 ___E,
5107 > for DeviceWriteConfig16Request
5108 where
5109 ___E: ::fidl_next::Encoder + ?Sized,
5110 DeviceWriteConfig16Request:
5111 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5112 {
5113 #[inline]
5114 fn encode_option(
5115 this: ::core::option::Option<Self>,
5116 encoder: &mut ___E,
5117 out: &mut ::core::mem::MaybeUninit<
5118 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5119 >,
5120 _: (),
5121 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5122 if let Some(inner) = this {
5123 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5124 ::fidl_next::wire::Box::encode_present(out);
5125 } else {
5126 ::fidl_next::wire::Box::encode_absent(out);
5127 }
5128
5129 Ok(())
5130 }
5131 }
5132
5133 unsafe impl<'a, ___E>
5134 ::fidl_next::EncodeOption<
5135 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5136 ___E,
5137 > for &'a DeviceWriteConfig16Request
5138 where
5139 ___E: ::fidl_next::Encoder + ?Sized,
5140 &'a DeviceWriteConfig16Request:
5141 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5142 {
5143 #[inline]
5144 fn encode_option(
5145 this: ::core::option::Option<Self>,
5146 encoder: &mut ___E,
5147 out: &mut ::core::mem::MaybeUninit<
5148 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5149 >,
5150 _: (),
5151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5152 if let Some(inner) = this {
5153 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5154 ::fidl_next::wire::Box::encode_present(out);
5155 } else {
5156 ::fidl_next::wire::Box::encode_absent(out);
5157 }
5158
5159 Ok(())
5160 }
5161 }
5162
5163 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig16Request> for DeviceWriteConfig16Request {
5164 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5165 crate::wire::DeviceWriteConfig16Request,
5166 Self,
5167 > = unsafe {
5168 ::fidl_next::CopyOptimization::enable_if(
5169 true
5170 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5171 .is_enabled()
5172 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5173 .is_enabled(),
5174 )
5175 };
5176
5177 #[inline]
5178 fn from_wire(wire: crate::wire::DeviceWriteConfig16Request) -> Self {
5179 Self {
5180 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5181
5182 value: ::fidl_next::FromWire::from_wire(wire.value),
5183 }
5184 }
5185 }
5186
5187 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig16Request>
5188 for DeviceWriteConfig16Request
5189 {
5190 #[inline]
5191 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig16Request) -> Self {
5192 Self {
5193 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5194
5195 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5196 }
5197 }
5198 }
5199
5200 pub type DeviceWriteConfig16Response = ();
5201
5202 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5203 pub struct DeviceWriteConfig32Request {
5204 pub offset: u16,
5205
5206 pub value: u32,
5207 }
5208
5209 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5210 for DeviceWriteConfig32Request
5211 where
5212 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5213 {
5214 #[inline]
5215 fn encode(
5216 self,
5217 encoder_: &mut ___E,
5218 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5219 _: (),
5220 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5221 ::fidl_next::munge! {
5222 let crate::wire::DeviceWriteConfig32Request {
5223 offset,
5224 value,
5225
5226 } = out_;
5227 }
5228
5229 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5230
5231 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5232
5233 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5234
5235 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5236
5237 Ok(())
5238 }
5239 }
5240
5241 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5242 for &'a DeviceWriteConfig32Request
5243 where
5244 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5245 {
5246 #[inline]
5247 fn encode(
5248 self,
5249 encoder_: &mut ___E,
5250 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5251 _: (),
5252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5253 ::fidl_next::munge! {
5254 let crate::wire::DeviceWriteConfig32Request {
5255 offset,
5256 value,
5257
5258 } = out_;
5259 }
5260
5261 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5262
5263 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5264
5265 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5266
5267 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5268
5269 Ok(())
5270 }
5271 }
5272
5273 unsafe impl<___E>
5274 ::fidl_next::EncodeOption<
5275 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5276 ___E,
5277 > for DeviceWriteConfig32Request
5278 where
5279 ___E: ::fidl_next::Encoder + ?Sized,
5280 DeviceWriteConfig32Request:
5281 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5282 {
5283 #[inline]
5284 fn encode_option(
5285 this: ::core::option::Option<Self>,
5286 encoder: &mut ___E,
5287 out: &mut ::core::mem::MaybeUninit<
5288 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5289 >,
5290 _: (),
5291 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5292 if let Some(inner) = this {
5293 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5294 ::fidl_next::wire::Box::encode_present(out);
5295 } else {
5296 ::fidl_next::wire::Box::encode_absent(out);
5297 }
5298
5299 Ok(())
5300 }
5301 }
5302
5303 unsafe impl<'a, ___E>
5304 ::fidl_next::EncodeOption<
5305 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5306 ___E,
5307 > for &'a DeviceWriteConfig32Request
5308 where
5309 ___E: ::fidl_next::Encoder + ?Sized,
5310 &'a DeviceWriteConfig32Request:
5311 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5312 {
5313 #[inline]
5314 fn encode_option(
5315 this: ::core::option::Option<Self>,
5316 encoder: &mut ___E,
5317 out: &mut ::core::mem::MaybeUninit<
5318 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5319 >,
5320 _: (),
5321 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5322 if let Some(inner) = this {
5323 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5324 ::fidl_next::wire::Box::encode_present(out);
5325 } else {
5326 ::fidl_next::wire::Box::encode_absent(out);
5327 }
5328
5329 Ok(())
5330 }
5331 }
5332
5333 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig32Request> for DeviceWriteConfig32Request {
5334 #[inline]
5335 fn from_wire(wire: crate::wire::DeviceWriteConfig32Request) -> Self {
5336 Self {
5337 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5338
5339 value: ::fidl_next::FromWire::from_wire(wire.value),
5340 }
5341 }
5342 }
5343
5344 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig32Request>
5345 for DeviceWriteConfig32Request
5346 {
5347 #[inline]
5348 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig32Request) -> Self {
5349 Self {
5350 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5351
5352 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5353 }
5354 }
5355 }
5356
5357 pub type DeviceWriteConfig32Response = ();
5358
5359 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5360 #[repr(C)]
5361 pub struct DeviceGetCapabilitiesRequest {
5362 pub id: crate::natural::CapabilityId,
5363 }
5364
5365 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5366 for DeviceGetCapabilitiesRequest
5367 where
5368 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5369 {
5370 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5371 Self,
5372 crate::wire::DeviceGetCapabilitiesRequest,
5373 > = unsafe {
5374 ::fidl_next::CopyOptimization::enable_if(
5375 true && <crate::natural::CapabilityId as ::fidl_next::Encode<
5376 crate::wire::CapabilityId,
5377 ___E,
5378 >>::COPY_OPTIMIZATION
5379 .is_enabled(),
5380 )
5381 };
5382
5383 #[inline]
5384 fn encode(
5385 self,
5386 encoder_: &mut ___E,
5387 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5388 _: (),
5389 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5390 ::fidl_next::munge! {
5391 let crate::wire::DeviceGetCapabilitiesRequest {
5392 id,
5393
5394 } = out_;
5395 }
5396
5397 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5398
5399 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5400
5401 Ok(())
5402 }
5403 }
5404
5405 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5406 for &'a DeviceGetCapabilitiesRequest
5407 where
5408 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5409 {
5410 #[inline]
5411 fn encode(
5412 self,
5413 encoder_: &mut ___E,
5414 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5415 _: (),
5416 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5417 ::fidl_next::munge! {
5418 let crate::wire::DeviceGetCapabilitiesRequest {
5419 id,
5420
5421 } = out_;
5422 }
5423
5424 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
5425
5426 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5427
5428 Ok(())
5429 }
5430 }
5431
5432 unsafe impl<___E>
5433 ::fidl_next::EncodeOption<
5434 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5435 ___E,
5436 > for DeviceGetCapabilitiesRequest
5437 where
5438 ___E: ::fidl_next::Encoder + ?Sized,
5439 DeviceGetCapabilitiesRequest:
5440 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5441 {
5442 #[inline]
5443 fn encode_option(
5444 this: ::core::option::Option<Self>,
5445 encoder: &mut ___E,
5446 out: &mut ::core::mem::MaybeUninit<
5447 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5448 >,
5449 _: (),
5450 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5451 if let Some(inner) = this {
5452 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5453 ::fidl_next::wire::Box::encode_present(out);
5454 } else {
5455 ::fidl_next::wire::Box::encode_absent(out);
5456 }
5457
5458 Ok(())
5459 }
5460 }
5461
5462 unsafe impl<'a, ___E>
5463 ::fidl_next::EncodeOption<
5464 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5465 ___E,
5466 > for &'a DeviceGetCapabilitiesRequest
5467 where
5468 ___E: ::fidl_next::Encoder + ?Sized,
5469 &'a DeviceGetCapabilitiesRequest:
5470 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5471 {
5472 #[inline]
5473 fn encode_option(
5474 this: ::core::option::Option<Self>,
5475 encoder: &mut ___E,
5476 out: &mut ::core::mem::MaybeUninit<
5477 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5478 >,
5479 _: (),
5480 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5481 if let Some(inner) = this {
5482 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5483 ::fidl_next::wire::Box::encode_present(out);
5484 } else {
5485 ::fidl_next::wire::Box::encode_absent(out);
5486 }
5487
5488 Ok(())
5489 }
5490 }
5491
5492 impl ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesRequest>
5493 for DeviceGetCapabilitiesRequest
5494 {
5495 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5496 crate::wire::DeviceGetCapabilitiesRequest,
5497 Self,
5498 > = unsafe {
5499 ::fidl_next::CopyOptimization::enable_if(
5500 true && <crate::natural::CapabilityId as ::fidl_next::FromWire<
5501 crate::wire::CapabilityId,
5502 >>::COPY_OPTIMIZATION
5503 .is_enabled(),
5504 )
5505 };
5506
5507 #[inline]
5508 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5509 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
5510 }
5511 }
5512
5513 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesRequest>
5514 for DeviceGetCapabilitiesRequest
5515 {
5516 #[inline]
5517 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5518 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
5519 }
5520 }
5521
5522 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5523 pub struct DeviceGetCapabilitiesResponse {
5524 pub offsets: ::std::vec::Vec<u8>,
5525 }
5526
5527 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
5528 for DeviceGetCapabilitiesResponse
5529 where
5530 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5531 ___E: ::fidl_next::Encoder,
5532 {
5533 #[inline]
5534 fn encode(
5535 self,
5536 encoder_: &mut ___E,
5537 out_: &mut ::core::mem::MaybeUninit<
5538 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5539 >,
5540 _: (),
5541 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5542 ::fidl_next::munge! {
5543 let crate::wire::DeviceGetCapabilitiesResponse {
5544 offsets,
5545
5546 } = out_;
5547 }
5548
5549 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
5550
5551 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
5552 ::fidl_next::Constrained::validate(_field, (32, ()))?;
5553
5554 Ok(())
5555 }
5556 }
5557
5558 unsafe impl<'a, ___E>
5559 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
5560 for &'a DeviceGetCapabilitiesResponse
5561 where
5562 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5563 ___E: ::fidl_next::Encoder,
5564 {
5565 #[inline]
5566 fn encode(
5567 self,
5568 encoder_: &mut ___E,
5569 out_: &mut ::core::mem::MaybeUninit<
5570 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5571 >,
5572 _: (),
5573 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5574 ::fidl_next::munge! {
5575 let crate::wire::DeviceGetCapabilitiesResponse {
5576 offsets,
5577
5578 } = out_;
5579 }
5580
5581 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
5582
5583 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
5584 ::fidl_next::Constrained::validate(_field, (32, ()))?;
5585
5586 Ok(())
5587 }
5588 }
5589
5590 unsafe impl<___E>
5591 ::fidl_next::EncodeOption<
5592 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
5593 ___E,
5594 > for DeviceGetCapabilitiesResponse
5595 where
5596 ___E: ::fidl_next::Encoder + ?Sized,
5597 DeviceGetCapabilitiesResponse:
5598 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
5599 {
5600 #[inline]
5601 fn encode_option(
5602 this: ::core::option::Option<Self>,
5603 encoder: &mut ___E,
5604 out: &mut ::core::mem::MaybeUninit<
5605 ::fidl_next::wire::Box<
5606 'static,
5607 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5608 >,
5609 >,
5610 _: (),
5611 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5612 if let Some(inner) = this {
5613 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5614 ::fidl_next::wire::Box::encode_present(out);
5615 } else {
5616 ::fidl_next::wire::Box::encode_absent(out);
5617 }
5618
5619 Ok(())
5620 }
5621 }
5622
5623 unsafe impl<'a, ___E>
5624 ::fidl_next::EncodeOption<
5625 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
5626 ___E,
5627 > for &'a DeviceGetCapabilitiesResponse
5628 where
5629 ___E: ::fidl_next::Encoder + ?Sized,
5630 &'a DeviceGetCapabilitiesResponse:
5631 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
5632 {
5633 #[inline]
5634 fn encode_option(
5635 this: ::core::option::Option<Self>,
5636 encoder: &mut ___E,
5637 out: &mut ::core::mem::MaybeUninit<
5638 ::fidl_next::wire::Box<
5639 'static,
5640 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5641 >,
5642 >,
5643 _: (),
5644 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5645 if let Some(inner) = this {
5646 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5647 ::fidl_next::wire::Box::encode_present(out);
5648 } else {
5649 ::fidl_next::wire::Box::encode_absent(out);
5650 }
5651
5652 Ok(())
5653 }
5654 }
5655
5656 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesResponse<'de>>
5657 for DeviceGetCapabilitiesResponse
5658 {
5659 #[inline]
5660 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
5661 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
5662 }
5663 }
5664
5665 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesResponse<'de>>
5666 for DeviceGetCapabilitiesResponse
5667 {
5668 #[inline]
5669 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
5670 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
5671 }
5672 }
5673
5674 #[doc = " PCI Extended Capability IDs.\n PCIe Base Specification rev4, chapter 7.6.\n"]
5675 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5676 #[repr(u16)]
5677 pub enum ExtendedCapabilityId {
5678 Null = 0,
5679 AdvancedErrorReporting = 1,
5680 VirtualChannelNoMfvc = 2,
5681 DeviceSerialNumber = 3,
5682 PowerBudgeting = 4,
5683 RootComplexLinkDeclaration = 5,
5684 RootComplexInternalLinkControl = 6,
5685 RootComplexEventCollectorEndpointAssociation = 7,
5686 MultiFunctionVirtualChannel = 8,
5687 VirtualChannel = 9,
5688 Rcrb = 10,
5689 Vendor = 11,
5690 Cac = 12,
5691 Acs = 13,
5692 Ari = 14,
5693 Ats = 15,
5694 SrIov = 16,
5695 MrIov = 17,
5696 Multicast = 18,
5697 Pri = 19,
5698 EnhancedAllocation = 20,
5699 ResizableBar = 21,
5700 DynamicPowerAllocation = 22,
5701 Tph = 23,
5702 LatencyToleranceReporting = 24,
5703 SecondaryPciExpress = 25,
5704 Pmux = 26,
5705 Pasid = 27,
5706 Lnr = 28,
5707 Dpc = 29,
5708 L1PmSubstates = 30,
5709 PrecisionTimeMeasurement = 31,
5710 Mpcie = 32,
5711 FrsQueueing = 33,
5712 ReadinessTimeReporting = 34,
5713 DesignatedVendor = 35,
5714 VfResizableBar = 36,
5715 DataLinkFeature = 37,
5716 PhysicalLayer16 = 38,
5717 LaneMarginingAtReceiver = 39,
5718 HierarchyId = 40,
5719 NativePcieEnclosure = 41,
5720 PhysicalLayer32 = 42,
5721 AlternateProtocol = 43,
5722 SystemFirmwareIntermediary = 44,
5723 UnknownOrdinal_(u16) = 45,
5724 }
5725 impl ::std::convert::From<u16> for ExtendedCapabilityId {
5726 fn from(value: u16) -> Self {
5727 match value {
5728 0 => Self::Null,
5729 1 => Self::AdvancedErrorReporting,
5730 2 => Self::VirtualChannelNoMfvc,
5731 3 => Self::DeviceSerialNumber,
5732 4 => Self::PowerBudgeting,
5733 5 => Self::RootComplexLinkDeclaration,
5734 6 => Self::RootComplexInternalLinkControl,
5735 7 => Self::RootComplexEventCollectorEndpointAssociation,
5736 8 => Self::MultiFunctionVirtualChannel,
5737 9 => Self::VirtualChannel,
5738 10 => Self::Rcrb,
5739 11 => Self::Vendor,
5740 12 => Self::Cac,
5741 13 => Self::Acs,
5742 14 => Self::Ari,
5743 15 => Self::Ats,
5744 16 => Self::SrIov,
5745 17 => Self::MrIov,
5746 18 => Self::Multicast,
5747 19 => Self::Pri,
5748 20 => Self::EnhancedAllocation,
5749 21 => Self::ResizableBar,
5750 22 => Self::DynamicPowerAllocation,
5751 23 => Self::Tph,
5752 24 => Self::LatencyToleranceReporting,
5753 25 => Self::SecondaryPciExpress,
5754 26 => Self::Pmux,
5755 27 => Self::Pasid,
5756 28 => Self::Lnr,
5757 29 => Self::Dpc,
5758 30 => Self::L1PmSubstates,
5759 31 => Self::PrecisionTimeMeasurement,
5760 32 => Self::Mpcie,
5761 33 => Self::FrsQueueing,
5762 34 => Self::ReadinessTimeReporting,
5763 35 => Self::DesignatedVendor,
5764 36 => Self::VfResizableBar,
5765 37 => Self::DataLinkFeature,
5766 38 => Self::PhysicalLayer16,
5767 39 => Self::LaneMarginingAtReceiver,
5768 40 => Self::HierarchyId,
5769 41 => Self::NativePcieEnclosure,
5770 42 => Self::PhysicalLayer32,
5771 43 => Self::AlternateProtocol,
5772 44 => Self::SystemFirmwareIntermediary,
5773
5774 _ => Self::UnknownOrdinal_(value),
5775 }
5776 }
5777 }
5778
5779 impl ::std::convert::From<ExtendedCapabilityId> for u16 {
5780 fn from(value: ExtendedCapabilityId) -> Self {
5781 match value {
5782 ExtendedCapabilityId::Null => 0,
5783 ExtendedCapabilityId::AdvancedErrorReporting => 1,
5784 ExtendedCapabilityId::VirtualChannelNoMfvc => 2,
5785 ExtendedCapabilityId::DeviceSerialNumber => 3,
5786 ExtendedCapabilityId::PowerBudgeting => 4,
5787 ExtendedCapabilityId::RootComplexLinkDeclaration => 5,
5788 ExtendedCapabilityId::RootComplexInternalLinkControl => 6,
5789 ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => 7,
5790 ExtendedCapabilityId::MultiFunctionVirtualChannel => 8,
5791 ExtendedCapabilityId::VirtualChannel => 9,
5792 ExtendedCapabilityId::Rcrb => 10,
5793 ExtendedCapabilityId::Vendor => 11,
5794 ExtendedCapabilityId::Cac => 12,
5795 ExtendedCapabilityId::Acs => 13,
5796 ExtendedCapabilityId::Ari => 14,
5797 ExtendedCapabilityId::Ats => 15,
5798 ExtendedCapabilityId::SrIov => 16,
5799 ExtendedCapabilityId::MrIov => 17,
5800 ExtendedCapabilityId::Multicast => 18,
5801 ExtendedCapabilityId::Pri => 19,
5802 ExtendedCapabilityId::EnhancedAllocation => 20,
5803 ExtendedCapabilityId::ResizableBar => 21,
5804 ExtendedCapabilityId::DynamicPowerAllocation => 22,
5805 ExtendedCapabilityId::Tph => 23,
5806 ExtendedCapabilityId::LatencyToleranceReporting => 24,
5807 ExtendedCapabilityId::SecondaryPciExpress => 25,
5808 ExtendedCapabilityId::Pmux => 26,
5809 ExtendedCapabilityId::Pasid => 27,
5810 ExtendedCapabilityId::Lnr => 28,
5811 ExtendedCapabilityId::Dpc => 29,
5812 ExtendedCapabilityId::L1PmSubstates => 30,
5813 ExtendedCapabilityId::PrecisionTimeMeasurement => 31,
5814 ExtendedCapabilityId::Mpcie => 32,
5815 ExtendedCapabilityId::FrsQueueing => 33,
5816 ExtendedCapabilityId::ReadinessTimeReporting => 34,
5817 ExtendedCapabilityId::DesignatedVendor => 35,
5818 ExtendedCapabilityId::VfResizableBar => 36,
5819 ExtendedCapabilityId::DataLinkFeature => 37,
5820 ExtendedCapabilityId::PhysicalLayer16 => 38,
5821 ExtendedCapabilityId::LaneMarginingAtReceiver => 39,
5822 ExtendedCapabilityId::HierarchyId => 40,
5823 ExtendedCapabilityId::NativePcieEnclosure => 41,
5824 ExtendedCapabilityId::PhysicalLayer32 => 42,
5825 ExtendedCapabilityId::AlternateProtocol => 43,
5826 ExtendedCapabilityId::SystemFirmwareIntermediary => 44,
5827
5828 ExtendedCapabilityId::UnknownOrdinal_(value) => value,
5829 }
5830 }
5831 }
5832
5833 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
5834 for ExtendedCapabilityId
5835 where
5836 ___E: ?Sized,
5837 {
5838 #[inline]
5839 fn encode(
5840 self,
5841 encoder: &mut ___E,
5842 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
5843 _: (),
5844 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5845 ::fidl_next::Encode::encode(&self, encoder, out, ())
5846 }
5847 }
5848
5849 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
5850 for &'a ExtendedCapabilityId
5851 where
5852 ___E: ?Sized,
5853 {
5854 #[inline]
5855 fn encode(
5856 self,
5857 encoder: &mut ___E,
5858 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
5859 _: (),
5860 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5861 ::fidl_next::munge!(let crate::wire::ExtendedCapabilityId { value } = out);
5862 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
5863 ExtendedCapabilityId::Null => 0,
5864
5865 ExtendedCapabilityId::AdvancedErrorReporting => 1,
5866
5867 ExtendedCapabilityId::VirtualChannelNoMfvc => 2,
5868
5869 ExtendedCapabilityId::DeviceSerialNumber => 3,
5870
5871 ExtendedCapabilityId::PowerBudgeting => 4,
5872
5873 ExtendedCapabilityId::RootComplexLinkDeclaration => 5,
5874
5875 ExtendedCapabilityId::RootComplexInternalLinkControl => 6,
5876
5877 ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => 7,
5878
5879 ExtendedCapabilityId::MultiFunctionVirtualChannel => 8,
5880
5881 ExtendedCapabilityId::VirtualChannel => 9,
5882
5883 ExtendedCapabilityId::Rcrb => 10,
5884
5885 ExtendedCapabilityId::Vendor => 11,
5886
5887 ExtendedCapabilityId::Cac => 12,
5888
5889 ExtendedCapabilityId::Acs => 13,
5890
5891 ExtendedCapabilityId::Ari => 14,
5892
5893 ExtendedCapabilityId::Ats => 15,
5894
5895 ExtendedCapabilityId::SrIov => 16,
5896
5897 ExtendedCapabilityId::MrIov => 17,
5898
5899 ExtendedCapabilityId::Multicast => 18,
5900
5901 ExtendedCapabilityId::Pri => 19,
5902
5903 ExtendedCapabilityId::EnhancedAllocation => 20,
5904
5905 ExtendedCapabilityId::ResizableBar => 21,
5906
5907 ExtendedCapabilityId::DynamicPowerAllocation => 22,
5908
5909 ExtendedCapabilityId::Tph => 23,
5910
5911 ExtendedCapabilityId::LatencyToleranceReporting => 24,
5912
5913 ExtendedCapabilityId::SecondaryPciExpress => 25,
5914
5915 ExtendedCapabilityId::Pmux => 26,
5916
5917 ExtendedCapabilityId::Pasid => 27,
5918
5919 ExtendedCapabilityId::Lnr => 28,
5920
5921 ExtendedCapabilityId::Dpc => 29,
5922
5923 ExtendedCapabilityId::L1PmSubstates => 30,
5924
5925 ExtendedCapabilityId::PrecisionTimeMeasurement => 31,
5926
5927 ExtendedCapabilityId::Mpcie => 32,
5928
5929 ExtendedCapabilityId::FrsQueueing => 33,
5930
5931 ExtendedCapabilityId::ReadinessTimeReporting => 34,
5932
5933 ExtendedCapabilityId::DesignatedVendor => 35,
5934
5935 ExtendedCapabilityId::VfResizableBar => 36,
5936
5937 ExtendedCapabilityId::DataLinkFeature => 37,
5938
5939 ExtendedCapabilityId::PhysicalLayer16 => 38,
5940
5941 ExtendedCapabilityId::LaneMarginingAtReceiver => 39,
5942
5943 ExtendedCapabilityId::HierarchyId => 40,
5944
5945 ExtendedCapabilityId::NativePcieEnclosure => 41,
5946
5947 ExtendedCapabilityId::PhysicalLayer32 => 42,
5948
5949 ExtendedCapabilityId::AlternateProtocol => 43,
5950
5951 ExtendedCapabilityId::SystemFirmwareIntermediary => 44,
5952
5953 ExtendedCapabilityId::UnknownOrdinal_(value) => value,
5954 }));
5955
5956 Ok(())
5957 }
5958 }
5959
5960 impl ::core::convert::From<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
5961 fn from(wire: crate::wire::ExtendedCapabilityId) -> Self {
5962 match u16::from(wire.value) {
5963 0 => Self::Null,
5964
5965 1 => Self::AdvancedErrorReporting,
5966
5967 2 => Self::VirtualChannelNoMfvc,
5968
5969 3 => Self::DeviceSerialNumber,
5970
5971 4 => Self::PowerBudgeting,
5972
5973 5 => Self::RootComplexLinkDeclaration,
5974
5975 6 => Self::RootComplexInternalLinkControl,
5976
5977 7 => Self::RootComplexEventCollectorEndpointAssociation,
5978
5979 8 => Self::MultiFunctionVirtualChannel,
5980
5981 9 => Self::VirtualChannel,
5982
5983 10 => Self::Rcrb,
5984
5985 11 => Self::Vendor,
5986
5987 12 => Self::Cac,
5988
5989 13 => Self::Acs,
5990
5991 14 => Self::Ari,
5992
5993 15 => Self::Ats,
5994
5995 16 => Self::SrIov,
5996
5997 17 => Self::MrIov,
5998
5999 18 => Self::Multicast,
6000
6001 19 => Self::Pri,
6002
6003 20 => Self::EnhancedAllocation,
6004
6005 21 => Self::ResizableBar,
6006
6007 22 => Self::DynamicPowerAllocation,
6008
6009 23 => Self::Tph,
6010
6011 24 => Self::LatencyToleranceReporting,
6012
6013 25 => Self::SecondaryPciExpress,
6014
6015 26 => Self::Pmux,
6016
6017 27 => Self::Pasid,
6018
6019 28 => Self::Lnr,
6020
6021 29 => Self::Dpc,
6022
6023 30 => Self::L1PmSubstates,
6024
6025 31 => Self::PrecisionTimeMeasurement,
6026
6027 32 => Self::Mpcie,
6028
6029 33 => Self::FrsQueueing,
6030
6031 34 => Self::ReadinessTimeReporting,
6032
6033 35 => Self::DesignatedVendor,
6034
6035 36 => Self::VfResizableBar,
6036
6037 37 => Self::DataLinkFeature,
6038
6039 38 => Self::PhysicalLayer16,
6040
6041 39 => Self::LaneMarginingAtReceiver,
6042
6043 40 => Self::HierarchyId,
6044
6045 41 => Self::NativePcieEnclosure,
6046
6047 42 => Self::PhysicalLayer32,
6048
6049 43 => Self::AlternateProtocol,
6050
6051 44 => Self::SystemFirmwareIntermediary,
6052
6053 value => Self::UnknownOrdinal_(value),
6054 }
6055 }
6056 }
6057
6058 impl ::fidl_next::FromWire<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
6059 #[inline]
6060 fn from_wire(wire: crate::wire::ExtendedCapabilityId) -> Self {
6061 Self::from(wire)
6062 }
6063 }
6064
6065 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
6066 #[inline]
6067 fn from_wire_ref(wire: &crate::wire::ExtendedCapabilityId) -> Self {
6068 Self::from(*wire)
6069 }
6070 }
6071
6072 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6073 #[repr(C)]
6074 pub struct DeviceGetExtendedCapabilitiesRequest {
6075 pub id: crate::natural::ExtendedCapabilityId,
6076 }
6077
6078 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
6079 for DeviceGetExtendedCapabilitiesRequest
6080 where
6081 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6082 {
6083 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6084 Self,
6085 crate::wire::DeviceGetExtendedCapabilitiesRequest,
6086 > = unsafe {
6087 ::fidl_next::CopyOptimization::enable_if(
6088 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::Encode<
6089 crate::wire::ExtendedCapabilityId,
6090 ___E,
6091 >>::COPY_OPTIMIZATION
6092 .is_enabled(),
6093 )
6094 };
6095
6096 #[inline]
6097 fn encode(
6098 self,
6099 encoder_: &mut ___E,
6100 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6101 _: (),
6102 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6103 ::fidl_next::munge! {
6104 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
6105 id,
6106
6107 } = out_;
6108 }
6109
6110 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
6111
6112 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
6113
6114 Ok(())
6115 }
6116 }
6117
6118 unsafe impl<'a, ___E>
6119 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
6120 for &'a DeviceGetExtendedCapabilitiesRequest
6121 where
6122 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6123 {
6124 #[inline]
6125 fn encode(
6126 self,
6127 encoder_: &mut ___E,
6128 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6129 _: (),
6130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6131 ::fidl_next::munge! {
6132 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
6133 id,
6134
6135 } = out_;
6136 }
6137
6138 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
6139
6140 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
6141
6142 Ok(())
6143 }
6144 }
6145
6146 unsafe impl<___E>
6147 ::fidl_next::EncodeOption<
6148 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6149 ___E,
6150 > for DeviceGetExtendedCapabilitiesRequest
6151 where
6152 ___E: ::fidl_next::Encoder + ?Sized,
6153 DeviceGetExtendedCapabilitiesRequest:
6154 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
6155 {
6156 #[inline]
6157 fn encode_option(
6158 this: ::core::option::Option<Self>,
6159 encoder: &mut ___E,
6160 out: &mut ::core::mem::MaybeUninit<
6161 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6162 >,
6163 _: (),
6164 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6165 if let Some(inner) = this {
6166 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6167 ::fidl_next::wire::Box::encode_present(out);
6168 } else {
6169 ::fidl_next::wire::Box::encode_absent(out);
6170 }
6171
6172 Ok(())
6173 }
6174 }
6175
6176 unsafe impl<'a, ___E>
6177 ::fidl_next::EncodeOption<
6178 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6179 ___E,
6180 > for &'a DeviceGetExtendedCapabilitiesRequest
6181 where
6182 ___E: ::fidl_next::Encoder + ?Sized,
6183 &'a DeviceGetExtendedCapabilitiesRequest:
6184 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
6185 {
6186 #[inline]
6187 fn encode_option(
6188 this: ::core::option::Option<Self>,
6189 encoder: &mut ___E,
6190 out: &mut ::core::mem::MaybeUninit<
6191 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6192 >,
6193 _: (),
6194 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6195 if let Some(inner) = this {
6196 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6197 ::fidl_next::wire::Box::encode_present(out);
6198 } else {
6199 ::fidl_next::wire::Box::encode_absent(out);
6200 }
6201
6202 Ok(())
6203 }
6204 }
6205
6206 impl ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6207 for DeviceGetExtendedCapabilitiesRequest
6208 {
6209 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6210 crate::wire::DeviceGetExtendedCapabilitiesRequest,
6211 Self,
6212 > = unsafe {
6213 ::fidl_next::CopyOptimization::enable_if(
6214 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::FromWire<
6215 crate::wire::ExtendedCapabilityId,
6216 >>::COPY_OPTIMIZATION
6217 .is_enabled(),
6218 )
6219 };
6220
6221 #[inline]
6222 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6223 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
6224 }
6225 }
6226
6227 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6228 for DeviceGetExtendedCapabilitiesRequest
6229 {
6230 #[inline]
6231 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6232 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
6233 }
6234 }
6235
6236 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6237 pub struct DeviceGetExtendedCapabilitiesResponse {
6238 pub offsets: ::std::vec::Vec<u16>,
6239 }
6240
6241 unsafe impl<___E>
6242 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6243 for DeviceGetExtendedCapabilitiesResponse
6244 where
6245 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6246 ___E: ::fidl_next::Encoder,
6247 {
6248 #[inline]
6249 fn encode(
6250 self,
6251 encoder_: &mut ___E,
6252 out_: &mut ::core::mem::MaybeUninit<
6253 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6254 >,
6255 _: (),
6256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6257 ::fidl_next::munge! {
6258 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6259 offsets,
6260
6261 } = out_;
6262 }
6263
6264 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
6265
6266 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6267 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6268
6269 Ok(())
6270 }
6271 }
6272
6273 unsafe impl<'a, ___E>
6274 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6275 for &'a DeviceGetExtendedCapabilitiesResponse
6276 where
6277 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6278 ___E: ::fidl_next::Encoder,
6279 {
6280 #[inline]
6281 fn encode(
6282 self,
6283 encoder_: &mut ___E,
6284 out_: &mut ::core::mem::MaybeUninit<
6285 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6286 >,
6287 _: (),
6288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6289 ::fidl_next::munge! {
6290 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6291 offsets,
6292
6293 } = out_;
6294 }
6295
6296 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
6297
6298 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6299 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6300
6301 Ok(())
6302 }
6303 }
6304
6305 unsafe impl<___E>
6306 ::fidl_next::EncodeOption<
6307 ::fidl_next::wire::Box<
6308 'static,
6309 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6310 >,
6311 ___E,
6312 > for DeviceGetExtendedCapabilitiesResponse
6313 where
6314 ___E: ::fidl_next::Encoder + ?Sized,
6315 DeviceGetExtendedCapabilitiesResponse:
6316 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6317 {
6318 #[inline]
6319 fn encode_option(
6320 this: ::core::option::Option<Self>,
6321 encoder: &mut ___E,
6322 out: &mut ::core::mem::MaybeUninit<
6323 ::fidl_next::wire::Box<
6324 'static,
6325 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6326 >,
6327 >,
6328 _: (),
6329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6330 if let Some(inner) = this {
6331 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6332 ::fidl_next::wire::Box::encode_present(out);
6333 } else {
6334 ::fidl_next::wire::Box::encode_absent(out);
6335 }
6336
6337 Ok(())
6338 }
6339 }
6340
6341 unsafe impl<'a, ___E>
6342 ::fidl_next::EncodeOption<
6343 ::fidl_next::wire::Box<
6344 'static,
6345 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6346 >,
6347 ___E,
6348 > for &'a DeviceGetExtendedCapabilitiesResponse
6349 where
6350 ___E: ::fidl_next::Encoder + ?Sized,
6351 &'a DeviceGetExtendedCapabilitiesResponse:
6352 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6353 {
6354 #[inline]
6355 fn encode_option(
6356 this: ::core::option::Option<Self>,
6357 encoder: &mut ___E,
6358 out: &mut ::core::mem::MaybeUninit<
6359 ::fidl_next::wire::Box<
6360 'static,
6361 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6362 >,
6363 >,
6364 _: (),
6365 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6366 if let Some(inner) = this {
6367 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6368 ::fidl_next::wire::Box::encode_present(out);
6369 } else {
6370 ::fidl_next::wire::Box::encode_absent(out);
6371 }
6372
6373 Ok(())
6374 }
6375 }
6376
6377 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6378 for DeviceGetExtendedCapabilitiesResponse
6379 {
6380 #[inline]
6381 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6382 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
6383 }
6384 }
6385
6386 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6387 for DeviceGetExtendedCapabilitiesResponse
6388 {
6389 #[inline]
6390 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6391 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
6392 }
6393 }
6394
6395 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6396 #[repr(C)]
6397 pub struct DeviceGetBtiRequest {
6398 pub index: u32,
6399 }
6400
6401 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6402 for DeviceGetBtiRequest
6403 where
6404 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6405 {
6406 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6407 Self,
6408 crate::wire::DeviceGetBtiRequest,
6409 > = unsafe {
6410 ::fidl_next::CopyOptimization::enable_if(
6411 true
6412
6413 && <
6414 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
6415 >::COPY_OPTIMIZATION.is_enabled()
6416
6417 )
6418 };
6419
6420 #[inline]
6421 fn encode(
6422 self,
6423 encoder_: &mut ___E,
6424 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6425 _: (),
6426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6427 ::fidl_next::munge! {
6428 let crate::wire::DeviceGetBtiRequest {
6429 index,
6430
6431 } = out_;
6432 }
6433
6434 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
6435
6436 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6437
6438 Ok(())
6439 }
6440 }
6441
6442 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6443 for &'a DeviceGetBtiRequest
6444 where
6445 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6446 {
6447 #[inline]
6448 fn encode(
6449 self,
6450 encoder_: &mut ___E,
6451 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6452 _: (),
6453 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6454 ::fidl_next::munge! {
6455 let crate::wire::DeviceGetBtiRequest {
6456 index,
6457
6458 } = out_;
6459 }
6460
6461 ::fidl_next::Encode::encode(&self.index, encoder_, index, ())?;
6462
6463 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6464
6465 Ok(())
6466 }
6467 }
6468
6469 unsafe impl<___E>
6470 ::fidl_next::EncodeOption<
6471 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6472 ___E,
6473 > for DeviceGetBtiRequest
6474 where
6475 ___E: ::fidl_next::Encoder + ?Sized,
6476 DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6477 {
6478 #[inline]
6479 fn encode_option(
6480 this: ::core::option::Option<Self>,
6481 encoder: &mut ___E,
6482 out: &mut ::core::mem::MaybeUninit<
6483 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6484 >,
6485 _: (),
6486 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6487 if let Some(inner) = this {
6488 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6489 ::fidl_next::wire::Box::encode_present(out);
6490 } else {
6491 ::fidl_next::wire::Box::encode_absent(out);
6492 }
6493
6494 Ok(())
6495 }
6496 }
6497
6498 unsafe impl<'a, ___E>
6499 ::fidl_next::EncodeOption<
6500 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6501 ___E,
6502 > for &'a DeviceGetBtiRequest
6503 where
6504 ___E: ::fidl_next::Encoder + ?Sized,
6505 &'a DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6506 {
6507 #[inline]
6508 fn encode_option(
6509 this: ::core::option::Option<Self>,
6510 encoder: &mut ___E,
6511 out: &mut ::core::mem::MaybeUninit<
6512 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6513 >,
6514 _: (),
6515 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6516 if let Some(inner) = this {
6517 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6518 ::fidl_next::wire::Box::encode_present(out);
6519 } else {
6520 ::fidl_next::wire::Box::encode_absent(out);
6521 }
6522
6523 Ok(())
6524 }
6525 }
6526
6527 impl ::fidl_next::FromWire<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
6528 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6529 crate::wire::DeviceGetBtiRequest,
6530 Self,
6531 > = unsafe {
6532 ::fidl_next::CopyOptimization::enable_if(
6533 true
6534 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
6535 .is_enabled(),
6536 )
6537 };
6538
6539 #[inline]
6540 fn from_wire(wire: crate::wire::DeviceGetBtiRequest) -> Self {
6541 Self { index: ::fidl_next::FromWire::from_wire(wire.index) }
6542 }
6543 }
6544
6545 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
6546 #[inline]
6547 fn from_wire_ref(wire: &crate::wire::DeviceGetBtiRequest) -> Self {
6548 Self { index: ::fidl_next::FromWireRef::from_wire_ref(&wire.index) }
6549 }
6550 }
6551
6552 #[doc = " Used with ||SetInterruptMode| to configure an interrupt mode for the device.\n Devices configured to use the LEGACY Irq mode must ack their interrupt after\n servicing by calling |AckInterrupt|. To avoid this, LEGACY_NOACK can be\n used, but the driver\'s interrupt function will be disabled by the PCI Bus\n Driver if it sees excessive interrupt triggers in a given period.\n"]
6553 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6554 #[repr(u8)]
6555 pub enum InterruptMode {
6556 Disabled = 0,
6557 Legacy = 1,
6558 LegacyNoack = 2,
6559 Msi = 3,
6560 MsiX = 4,
6561 UnknownOrdinal_(u8) = 5,
6562 }
6563 impl ::std::convert::From<u8> for InterruptMode {
6564 fn from(value: u8) -> Self {
6565 match value {
6566 0 => Self::Disabled,
6567 1 => Self::Legacy,
6568 2 => Self::LegacyNoack,
6569 3 => Self::Msi,
6570 4 => Self::MsiX,
6571
6572 _ => Self::UnknownOrdinal_(value),
6573 }
6574 }
6575 }
6576
6577 impl ::std::convert::From<InterruptMode> for u8 {
6578 fn from(value: InterruptMode) -> Self {
6579 match value {
6580 InterruptMode::Disabled => 0,
6581 InterruptMode::Legacy => 1,
6582 InterruptMode::LegacyNoack => 2,
6583 InterruptMode::Msi => 3,
6584 InterruptMode::MsiX => 4,
6585
6586 InterruptMode::UnknownOrdinal_(value) => value,
6587 }
6588 }
6589 }
6590
6591 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for InterruptMode
6592 where
6593 ___E: ?Sized,
6594 {
6595 #[inline]
6596 fn encode(
6597 self,
6598 encoder: &mut ___E,
6599 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
6600 _: (),
6601 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6602 ::fidl_next::Encode::encode(&self, encoder, out, ())
6603 }
6604 }
6605
6606 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for &'a InterruptMode
6607 where
6608 ___E: ?Sized,
6609 {
6610 #[inline]
6611 fn encode(
6612 self,
6613 encoder: &mut ___E,
6614 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
6615 _: (),
6616 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6617 ::fidl_next::munge!(let crate::wire::InterruptMode { value } = out);
6618 let _ = value.write(u8::from(match *self {
6619 InterruptMode::Disabled => 0,
6620
6621 InterruptMode::Legacy => 1,
6622
6623 InterruptMode::LegacyNoack => 2,
6624
6625 InterruptMode::Msi => 3,
6626
6627 InterruptMode::MsiX => 4,
6628
6629 InterruptMode::UnknownOrdinal_(value) => value,
6630 }));
6631
6632 Ok(())
6633 }
6634 }
6635
6636 impl ::core::convert::From<crate::wire::InterruptMode> for InterruptMode {
6637 fn from(wire: crate::wire::InterruptMode) -> Self {
6638 match u8::from(wire.value) {
6639 0 => Self::Disabled,
6640
6641 1 => Self::Legacy,
6642
6643 2 => Self::LegacyNoack,
6644
6645 3 => Self::Msi,
6646
6647 4 => Self::MsiX,
6648
6649 value => Self::UnknownOrdinal_(value),
6650 }
6651 }
6652 }
6653
6654 impl ::fidl_next::FromWire<crate::wire::InterruptMode> for InterruptMode {
6655 #[inline]
6656 fn from_wire(wire: crate::wire::InterruptMode) -> Self {
6657 Self::from(wire)
6658 }
6659 }
6660
6661 impl ::fidl_next::FromWireRef<crate::wire::InterruptMode> for InterruptMode {
6662 #[inline]
6663 fn from_wire_ref(wire: &crate::wire::InterruptMode) -> Self {
6664 Self::from(*wire)
6665 }
6666 }
6667
6668 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6669 pub struct DeviceSetInterruptModeRequest {
6670 pub mode: crate::natural::InterruptMode,
6671
6672 pub requested_irq_count: u32,
6673 }
6674
6675 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
6676 for DeviceSetInterruptModeRequest
6677 where
6678 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6679 {
6680 #[inline]
6681 fn encode(
6682 self,
6683 encoder_: &mut ___E,
6684 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
6685 _: (),
6686 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6687 ::fidl_next::munge! {
6688 let crate::wire::DeviceSetInterruptModeRequest {
6689 mode,
6690 requested_irq_count,
6691
6692 } = out_;
6693 }
6694
6695 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
6696
6697 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
6698
6699 ::fidl_next::Encode::encode(
6700 self.requested_irq_count,
6701 encoder_,
6702 requested_irq_count,
6703 (),
6704 )?;
6705
6706 let mut _field =
6707 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
6708
6709 Ok(())
6710 }
6711 }
6712
6713 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
6714 for &'a DeviceSetInterruptModeRequest
6715 where
6716 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6717 {
6718 #[inline]
6719 fn encode(
6720 self,
6721 encoder_: &mut ___E,
6722 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
6723 _: (),
6724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6725 ::fidl_next::munge! {
6726 let crate::wire::DeviceSetInterruptModeRequest {
6727 mode,
6728 requested_irq_count,
6729
6730 } = out_;
6731 }
6732
6733 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
6734
6735 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
6736
6737 ::fidl_next::Encode::encode(
6738 &self.requested_irq_count,
6739 encoder_,
6740 requested_irq_count,
6741 (),
6742 )?;
6743
6744 let mut _field =
6745 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
6746
6747 Ok(())
6748 }
6749 }
6750
6751 unsafe impl<___E>
6752 ::fidl_next::EncodeOption<
6753 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6754 ___E,
6755 > for DeviceSetInterruptModeRequest
6756 where
6757 ___E: ::fidl_next::Encoder + ?Sized,
6758 DeviceSetInterruptModeRequest:
6759 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
6760 {
6761 #[inline]
6762 fn encode_option(
6763 this: ::core::option::Option<Self>,
6764 encoder: &mut ___E,
6765 out: &mut ::core::mem::MaybeUninit<
6766 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6767 >,
6768 _: (),
6769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6770 if let Some(inner) = this {
6771 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6772 ::fidl_next::wire::Box::encode_present(out);
6773 } else {
6774 ::fidl_next::wire::Box::encode_absent(out);
6775 }
6776
6777 Ok(())
6778 }
6779 }
6780
6781 unsafe impl<'a, ___E>
6782 ::fidl_next::EncodeOption<
6783 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6784 ___E,
6785 > for &'a DeviceSetInterruptModeRequest
6786 where
6787 ___E: ::fidl_next::Encoder + ?Sized,
6788 &'a DeviceSetInterruptModeRequest:
6789 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
6790 {
6791 #[inline]
6792 fn encode_option(
6793 this: ::core::option::Option<Self>,
6794 encoder: &mut ___E,
6795 out: &mut ::core::mem::MaybeUninit<
6796 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6797 >,
6798 _: (),
6799 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6800 if let Some(inner) = this {
6801 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6802 ::fidl_next::wire::Box::encode_present(out);
6803 } else {
6804 ::fidl_next::wire::Box::encode_absent(out);
6805 }
6806
6807 Ok(())
6808 }
6809 }
6810
6811 impl ::fidl_next::FromWire<crate::wire::DeviceSetInterruptModeRequest>
6812 for DeviceSetInterruptModeRequest
6813 {
6814 #[inline]
6815 fn from_wire(wire: crate::wire::DeviceSetInterruptModeRequest) -> Self {
6816 Self {
6817 mode: ::fidl_next::FromWire::from_wire(wire.mode),
6818
6819 requested_irq_count: ::fidl_next::FromWire::from_wire(wire.requested_irq_count),
6820 }
6821 }
6822 }
6823
6824 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetInterruptModeRequest>
6825 for DeviceSetInterruptModeRequest
6826 {
6827 #[inline]
6828 fn from_wire_ref(wire: &crate::wire::DeviceSetInterruptModeRequest) -> Self {
6829 Self {
6830 mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
6831
6832 requested_irq_count: ::fidl_next::FromWireRef::from_wire_ref(
6833 &wire.requested_irq_count,
6834 ),
6835 }
6836 }
6837 }
6838
6839 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6840 #[repr(u8)]
6841 pub enum HeaderType {
6842 Standard = 0,
6843 Bridge = 1,
6844 CardBus = 2,
6845 Mask = 127,
6846 MultiFn = 128,
6847 UnknownOrdinal_(u8) = 129,
6848 }
6849 impl ::std::convert::From<u8> for HeaderType {
6850 fn from(value: u8) -> Self {
6851 match value {
6852 0 => Self::Standard,
6853 1 => Self::Bridge,
6854 2 => Self::CardBus,
6855 127 => Self::Mask,
6856 128 => Self::MultiFn,
6857
6858 _ => Self::UnknownOrdinal_(value),
6859 }
6860 }
6861 }
6862
6863 impl ::std::convert::From<HeaderType> for u8 {
6864 fn from(value: HeaderType) -> Self {
6865 match value {
6866 HeaderType::Standard => 0,
6867 HeaderType::Bridge => 1,
6868 HeaderType::CardBus => 2,
6869 HeaderType::Mask => 127,
6870 HeaderType::MultiFn => 128,
6871
6872 HeaderType::UnknownOrdinal_(value) => value,
6873 }
6874 }
6875 }
6876
6877 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for HeaderType
6878 where
6879 ___E: ?Sized,
6880 {
6881 #[inline]
6882 fn encode(
6883 self,
6884 encoder: &mut ___E,
6885 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
6886 _: (),
6887 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6888 ::fidl_next::Encode::encode(&self, encoder, out, ())
6889 }
6890 }
6891
6892 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for &'a HeaderType
6893 where
6894 ___E: ?Sized,
6895 {
6896 #[inline]
6897 fn encode(
6898 self,
6899 encoder: &mut ___E,
6900 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
6901 _: (),
6902 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6903 ::fidl_next::munge!(let crate::wire::HeaderType { value } = out);
6904 let _ = value.write(u8::from(match *self {
6905 HeaderType::Standard => 0,
6906
6907 HeaderType::Bridge => 1,
6908
6909 HeaderType::CardBus => 2,
6910
6911 HeaderType::Mask => 127,
6912
6913 HeaderType::MultiFn => 128,
6914
6915 HeaderType::UnknownOrdinal_(value) => value,
6916 }));
6917
6918 Ok(())
6919 }
6920 }
6921
6922 impl ::core::convert::From<crate::wire::HeaderType> for HeaderType {
6923 fn from(wire: crate::wire::HeaderType) -> Self {
6924 match u8::from(wire.value) {
6925 0 => Self::Standard,
6926
6927 1 => Self::Bridge,
6928
6929 2 => Self::CardBus,
6930
6931 127 => Self::Mask,
6932
6933 128 => Self::MultiFn,
6934
6935 value => Self::UnknownOrdinal_(value),
6936 }
6937 }
6938 }
6939
6940 impl ::fidl_next::FromWire<crate::wire::HeaderType> for HeaderType {
6941 #[inline]
6942 fn from_wire(wire: crate::wire::HeaderType) -> Self {
6943 Self::from(wire)
6944 }
6945 }
6946
6947 impl ::fidl_next::FromWireRef<crate::wire::HeaderType> for HeaderType {
6948 #[inline]
6949 fn from_wire_ref(wire: &crate::wire::HeaderType) -> Self {
6950 Self::from(*wire)
6951 }
6952 }
6953
6954 ::fidl_next::bitflags::bitflags! {
6955 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Status: u16 {
6956 const INTERRUPT = 8;
6957 const NEW_CAPS = 16;
6958 const SIXTYSIX_MHZ = 32;
6959 const FAST_B2_B = 128;
6960 const MSTR_PERR = 256;
6961 const DEVSEL_LOW = 512;
6962 const DEVSEL_HIGH = 1024;
6963 const TARG_ABORT_SIG = 2048;
6964 const TARG_ABORT_RCV = 4096;
6965 const MSTR_ABORT_RCV = 8192;
6966 const SERR_SIG = 16384;
6967 const PERR = 32768;
6968 const _ = !0;
6969 }
6970 }
6971
6972 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Status, ___E> for Status
6973 where
6974 ___E: ?Sized,
6975 {
6976 #[inline]
6977 fn encode(
6978 self,
6979 encoder: &mut ___E,
6980 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
6981 _: (),
6982 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6983 ::fidl_next::Encode::encode(&self, encoder, out, ())
6984 }
6985 }
6986
6987 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Status, ___E> for &'a Status
6988 where
6989 ___E: ?Sized,
6990 {
6991 #[inline]
6992 fn encode(
6993 self,
6994 _: &mut ___E,
6995 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
6996 _: (),
6997 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6998 ::fidl_next::munge!(let crate::wire::Status { value } = out);
6999
7000 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
7001 Ok(())
7002 }
7003 }
7004
7005 impl ::core::convert::From<crate::wire::Status> for Status {
7006 fn from(wire: crate::wire::Status) -> Self {
7007 Self::from_bits_retain(u16::from(wire.value))
7008 }
7009 }
7010
7011 impl ::fidl_next::FromWire<crate::wire::Status> for Status {
7012 #[inline]
7013 fn from_wire(wire: crate::wire::Status) -> Self {
7014 Self::from(wire)
7015 }
7016 }
7017
7018 impl ::fidl_next::FromWireRef<crate::wire::Status> for Status {
7019 #[inline]
7020 fn from_wire_ref(wire: &crate::wire::Status) -> Self {
7021 Self::from(*wire)
7022 }
7023 }
7024}
7025
7026pub mod wire {
7027
7028 #[derive(Clone, Debug)]
7030 #[repr(C)]
7031 pub struct Address {
7032 pub bus: u8,
7033
7034 pub device: u8,
7035
7036 pub function: u8,
7037 }
7038
7039 static_assertions::const_assert_eq!(std::mem::size_of::<Address>(), 3);
7040 static_assertions::const_assert_eq!(std::mem::align_of::<Address>(), 1);
7041
7042 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, bus), 0);
7043
7044 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, device), 1);
7045
7046 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, function), 2);
7047
7048 impl ::fidl_next::Constrained for Address {
7049 type Constraint = ();
7050
7051 fn validate(
7052 _: ::fidl_next::Slot<'_, Self>,
7053 _: Self::Constraint,
7054 ) -> Result<(), ::fidl_next::ValidationError> {
7055 Ok(())
7056 }
7057 }
7058
7059 unsafe impl ::fidl_next::Wire for Address {
7060 type Narrowed<'de> = Address;
7061
7062 #[inline]
7063 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7064 ::fidl_next::munge! {
7065 let Self {
7066 bus,
7067 device,
7068 function,
7069
7070 } = &mut *out_;
7071 }
7072
7073 ::fidl_next::Wire::zero_padding(bus);
7074
7075 ::fidl_next::Wire::zero_padding(device);
7076
7077 ::fidl_next::Wire::zero_padding(function);
7078 }
7079 }
7080
7081 unsafe impl<___D> ::fidl_next::Decode<___D> for Address
7082 where
7083 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7084 {
7085 fn decode(
7086 slot_: ::fidl_next::Slot<'_, Self>,
7087 decoder_: &mut ___D,
7088 _: (),
7089 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7090 ::fidl_next::munge! {
7091 let Self {
7092 mut bus,
7093 mut device,
7094 mut function,
7095
7096 } = slot_;
7097 }
7098
7099 let _field = bus.as_mut();
7100
7101 ::fidl_next::Decode::decode(bus.as_mut(), decoder_, ())?;
7102
7103 let _field = device.as_mut();
7104
7105 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
7106
7107 let _field = function.as_mut();
7108
7109 ::fidl_next::Decode::decode(function.as_mut(), decoder_, ())?;
7110
7111 Ok(())
7112 }
7113 }
7114
7115 impl ::fidl_next::IntoNatural for Address {
7116 type Natural = crate::natural::Address;
7117 }
7118
7119 #[derive(Clone, Debug)]
7121 #[repr(C)]
7122 pub struct BaseAddress {
7123 pub address: ::fidl_next::wire::Uint64,
7124
7125 pub size: ::fidl_next::wire::Uint64,
7126
7127 pub is_memory: bool,
7128
7129 pub is_prefetchable: bool,
7130
7131 pub is_64bit: bool,
7132
7133 pub id: u8,
7134 }
7135
7136 static_assertions::const_assert_eq!(std::mem::size_of::<BaseAddress>(), 24);
7137 static_assertions::const_assert_eq!(std::mem::align_of::<BaseAddress>(), 8);
7138
7139 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, address), 0);
7140
7141 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, size), 8);
7142
7143 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_memory), 16);
7144
7145 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_prefetchable), 17);
7146
7147 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_64bit), 18);
7148
7149 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, id), 19);
7150
7151 impl ::fidl_next::Constrained for BaseAddress {
7152 type Constraint = ();
7153
7154 fn validate(
7155 _: ::fidl_next::Slot<'_, Self>,
7156 _: Self::Constraint,
7157 ) -> Result<(), ::fidl_next::ValidationError> {
7158 Ok(())
7159 }
7160 }
7161
7162 unsafe impl ::fidl_next::Wire for BaseAddress {
7163 type Narrowed<'de> = BaseAddress;
7164
7165 #[inline]
7166 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7167 ::fidl_next::munge! {
7168 let Self {
7169 address,
7170 size,
7171 is_memory,
7172 is_prefetchable,
7173 is_64bit,
7174 id,
7175
7176 } = &mut *out_;
7177 }
7178
7179 ::fidl_next::Wire::zero_padding(address);
7180
7181 ::fidl_next::Wire::zero_padding(size);
7182
7183 ::fidl_next::Wire::zero_padding(is_memory);
7184
7185 ::fidl_next::Wire::zero_padding(is_prefetchable);
7186
7187 ::fidl_next::Wire::zero_padding(is_64bit);
7188
7189 ::fidl_next::Wire::zero_padding(id);
7190
7191 unsafe {
7192 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
7193 }
7194 }
7195 }
7196
7197 unsafe impl<___D> ::fidl_next::Decode<___D> for BaseAddress
7198 where
7199 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7200 {
7201 fn decode(
7202 slot_: ::fidl_next::Slot<'_, Self>,
7203 decoder_: &mut ___D,
7204 _: (),
7205 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7206 if slot_.as_bytes()[20..24] != [0u8; 4] {
7207 return Err(::fidl_next::DecodeError::InvalidPadding);
7208 }
7209
7210 ::fidl_next::munge! {
7211 let Self {
7212 mut address,
7213 mut size,
7214 mut is_memory,
7215 mut is_prefetchable,
7216 mut is_64bit,
7217 mut id,
7218
7219 } = slot_;
7220 }
7221
7222 let _field = address.as_mut();
7223
7224 ::fidl_next::Decode::decode(address.as_mut(), decoder_, ())?;
7225
7226 let _field = size.as_mut();
7227
7228 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
7229
7230 let _field = is_memory.as_mut();
7231
7232 ::fidl_next::Decode::decode(is_memory.as_mut(), decoder_, ())?;
7233
7234 let _field = is_prefetchable.as_mut();
7235
7236 ::fidl_next::Decode::decode(is_prefetchable.as_mut(), decoder_, ())?;
7237
7238 let _field = is_64bit.as_mut();
7239
7240 ::fidl_next::Decode::decode(is_64bit.as_mut(), decoder_, ())?;
7241
7242 let _field = id.as_mut();
7243
7244 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7245
7246 Ok(())
7247 }
7248 }
7249
7250 impl ::fidl_next::IntoNatural for BaseAddress {
7251 type Natural = crate::natural::BaseAddress;
7252 }
7253
7254 pub type UseIntxWorkaroundType = ::fidl_next::wire::Unit;
7256
7257 #[repr(C)]
7259 pub struct BoardConfiguration<'de> {
7260 pub(crate) table: ::fidl_next::wire::Table<'de>,
7261 }
7262
7263 impl<'de> Drop for BoardConfiguration<'de> {
7264 fn drop(&mut self) {
7265 let _ = self.table.get(1).map(|envelope| unsafe {
7266 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
7267 });
7268
7269 let _ = self.table.get(2).map(|envelope| unsafe {
7270 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>()
7271 });
7272 }
7273 }
7274
7275 impl ::fidl_next::Constrained for BoardConfiguration<'_> {
7276 type Constraint = ();
7277
7278 fn validate(
7279 _: ::fidl_next::Slot<'_, Self>,
7280 _: Self::Constraint,
7281 ) -> Result<(), ::fidl_next::ValidationError> {
7282 Ok(())
7283 }
7284 }
7285
7286 unsafe impl ::fidl_next::Wire for BoardConfiguration<'static> {
7287 type Narrowed<'de> = BoardConfiguration<'de>;
7288
7289 #[inline]
7290 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7291 ::fidl_next::munge!(let Self { table } = out);
7292 ::fidl_next::wire::Table::zero_padding(table);
7293 }
7294 }
7295
7296 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BoardConfiguration<'de>
7297 where
7298 ___D: ::fidl_next::Decoder<'de> + ?Sized,
7299 {
7300 fn decode(
7301 slot: ::fidl_next::Slot<'_, Self>,
7302 decoder: &mut ___D,
7303 _: (),
7304 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7305 ::fidl_next::munge!(let Self { table } = slot);
7306
7307 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
7308 match ordinal {
7309 0 => unsafe { ::core::hint::unreachable_unchecked() },
7310
7311 1 => {
7312 ::fidl_next::wire::Envelope::decode_as::<
7313 ___D,
7314 crate::wire::UseIntxWorkaroundType,
7315 >(slot.as_mut(), decoder, ())?;
7316
7317 Ok(())
7318 }
7319
7320 2 => {
7321 ::fidl_next::wire::Envelope::decode_as::<
7322 ___D,
7323 ::fidl_next::wire::Vector<'de, crate::wire::Address>,
7324 >(slot.as_mut(), decoder, (4294967295, ()))?;
7325
7326 Ok(())
7327 }
7328
7329 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
7330 }
7331 })
7332 }
7333 }
7334
7335 impl<'de> BoardConfiguration<'de> {
7336 pub fn use_intx_workaround(
7337 &self,
7338 ) -> ::core::option::Option<&crate::wire::UseIntxWorkaroundType> {
7339 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
7340 }
7341
7342 pub fn take_use_intx_workaround(
7343 &mut self,
7344 ) -> ::core::option::Option<crate::wire::UseIntxWorkaroundType> {
7345 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
7346 }
7347
7348 pub fn devicetree_bdfs(
7349 &self,
7350 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Address>> {
7351 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
7352 }
7353
7354 pub fn take_devicetree_bdfs(
7355 &mut self,
7356 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::Address>> {
7357 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
7358 }
7359 }
7360
7361 impl<'de> ::core::fmt::Debug for BoardConfiguration<'de> {
7362 fn fmt(
7363 &self,
7364 f: &mut ::core::fmt::Formatter<'_>,
7365 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7366 f.debug_struct("BoardConfiguration")
7367 .field("use_intx_workaround", &self.use_intx_workaround())
7368 .field("devicetree_bdfs", &self.devicetree_bdfs())
7369 .finish()
7370 }
7371 }
7372
7373 impl<'de> ::fidl_next::IntoNatural for BoardConfiguration<'de> {
7374 type Natural = crate::natural::BoardConfiguration;
7375 }
7376
7377 #[derive(Debug)]
7379 #[repr(C)]
7380 pub struct HostBridgeInfo<'de> {
7381 pub name: ::fidl_next::wire::String<'de>,
7382
7383 pub start_bus_number: u8,
7384
7385 pub end_bus_number: u8,
7386
7387 pub segment_group: ::fidl_next::wire::Uint16,
7388 }
7389
7390 static_assertions::const_assert_eq!(std::mem::size_of::<HostBridgeInfo<'_>>(), 24);
7391 static_assertions::const_assert_eq!(std::mem::align_of::<HostBridgeInfo<'_>>(), 8);
7392
7393 static_assertions::const_assert_eq!(std::mem::offset_of!(HostBridgeInfo<'_>, name), 0);
7394
7395 static_assertions::const_assert_eq!(
7396 std::mem::offset_of!(HostBridgeInfo<'_>, start_bus_number),
7397 16
7398 );
7399
7400 static_assertions::const_assert_eq!(
7401 std::mem::offset_of!(HostBridgeInfo<'_>, end_bus_number),
7402 17
7403 );
7404
7405 static_assertions::const_assert_eq!(
7406 std::mem::offset_of!(HostBridgeInfo<'_>, segment_group),
7407 18
7408 );
7409
7410 impl ::fidl_next::Constrained for HostBridgeInfo<'_> {
7411 type Constraint = ();
7412
7413 fn validate(
7414 _: ::fidl_next::Slot<'_, Self>,
7415 _: Self::Constraint,
7416 ) -> Result<(), ::fidl_next::ValidationError> {
7417 Ok(())
7418 }
7419 }
7420
7421 unsafe impl ::fidl_next::Wire for HostBridgeInfo<'static> {
7422 type Narrowed<'de> = HostBridgeInfo<'de>;
7423
7424 #[inline]
7425 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7426 ::fidl_next::munge! {
7427 let Self {
7428 name,
7429 start_bus_number,
7430 end_bus_number,
7431 segment_group,
7432
7433 } = &mut *out_;
7434 }
7435
7436 ::fidl_next::Wire::zero_padding(name);
7437
7438 ::fidl_next::Wire::zero_padding(start_bus_number);
7439
7440 ::fidl_next::Wire::zero_padding(end_bus_number);
7441
7442 ::fidl_next::Wire::zero_padding(segment_group);
7443
7444 unsafe {
7445 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
7446 }
7447 }
7448 }
7449
7450 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for HostBridgeInfo<'de>
7451 where
7452 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7453 ___D: ::fidl_next::Decoder<'de>,
7454 {
7455 fn decode(
7456 slot_: ::fidl_next::Slot<'_, Self>,
7457 decoder_: &mut ___D,
7458 _: (),
7459 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7460 if slot_.as_bytes()[20..24] != [0u8; 4] {
7461 return Err(::fidl_next::DecodeError::InvalidPadding);
7462 }
7463
7464 ::fidl_next::munge! {
7465 let Self {
7466 mut name,
7467 mut start_bus_number,
7468 mut end_bus_number,
7469 mut segment_group,
7470
7471 } = slot_;
7472 }
7473
7474 let _field = name.as_mut();
7475 ::fidl_next::Constrained::validate(_field, 32)?;
7476 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 32)?;
7477
7478 let name = unsafe { name.deref_unchecked() };
7479
7480 if name.len() > 32 {
7481 return Err(::fidl_next::DecodeError::VectorTooLong {
7482 size: name.len() as u64,
7483 limit: 32,
7484 });
7485 }
7486
7487 let _field = start_bus_number.as_mut();
7488
7489 ::fidl_next::Decode::decode(start_bus_number.as_mut(), decoder_, ())?;
7490
7491 let _field = end_bus_number.as_mut();
7492
7493 ::fidl_next::Decode::decode(end_bus_number.as_mut(), decoder_, ())?;
7494
7495 let _field = segment_group.as_mut();
7496
7497 ::fidl_next::Decode::decode(segment_group.as_mut(), decoder_, ())?;
7498
7499 Ok(())
7500 }
7501 }
7502
7503 impl<'de> ::fidl_next::IntoNatural for HostBridgeInfo<'de> {
7504 type Natural = crate::natural::HostBridgeInfo;
7505 }
7506
7507 #[derive(Debug)]
7509 #[repr(C)]
7510 pub struct BusGetHostBridgeInfoResponse<'de> {
7511 pub info: crate::wire::HostBridgeInfo<'de>,
7512 }
7513
7514 static_assertions::const_assert_eq!(
7515 std::mem::size_of::<BusGetHostBridgeInfoResponse<'_>>(),
7516 24
7517 );
7518 static_assertions::const_assert_eq!(
7519 std::mem::align_of::<BusGetHostBridgeInfoResponse<'_>>(),
7520 8
7521 );
7522
7523 static_assertions::const_assert_eq!(
7524 std::mem::offset_of!(BusGetHostBridgeInfoResponse<'_>, info),
7525 0
7526 );
7527
7528 impl ::fidl_next::Constrained for BusGetHostBridgeInfoResponse<'_> {
7529 type Constraint = ();
7530
7531 fn validate(
7532 _: ::fidl_next::Slot<'_, Self>,
7533 _: Self::Constraint,
7534 ) -> Result<(), ::fidl_next::ValidationError> {
7535 Ok(())
7536 }
7537 }
7538
7539 unsafe impl ::fidl_next::Wire for BusGetHostBridgeInfoResponse<'static> {
7540 type Narrowed<'de> = BusGetHostBridgeInfoResponse<'de>;
7541
7542 #[inline]
7543 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7544 ::fidl_next::munge! {
7545 let Self {
7546 info,
7547
7548 } = &mut *out_;
7549 }
7550
7551 ::fidl_next::Wire::zero_padding(info);
7552 }
7553 }
7554
7555 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetHostBridgeInfoResponse<'de>
7556 where
7557 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7558 ___D: ::fidl_next::Decoder<'de>,
7559 {
7560 fn decode(
7561 slot_: ::fidl_next::Slot<'_, Self>,
7562 decoder_: &mut ___D,
7563 _: (),
7564 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7565 ::fidl_next::munge! {
7566 let Self {
7567 mut info,
7568
7569 } = slot_;
7570 }
7571
7572 let _field = info.as_mut();
7573
7574 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
7575
7576 Ok(())
7577 }
7578 }
7579
7580 impl<'de> ::fidl_next::IntoNatural for BusGetHostBridgeInfoResponse<'de> {
7581 type Natural = crate::natural::BusGetHostBridgeInfoResponse;
7582 }
7583
7584 #[derive(Clone, Debug)]
7586 #[repr(C)]
7587 pub struct Capability {
7588 pub id: u8,
7589
7590 pub offset: u8,
7591 }
7592
7593 static_assertions::const_assert_eq!(std::mem::size_of::<Capability>(), 2);
7594 static_assertions::const_assert_eq!(std::mem::align_of::<Capability>(), 1);
7595
7596 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, id), 0);
7597
7598 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, offset), 1);
7599
7600 impl ::fidl_next::Constrained for Capability {
7601 type Constraint = ();
7602
7603 fn validate(
7604 _: ::fidl_next::Slot<'_, Self>,
7605 _: Self::Constraint,
7606 ) -> Result<(), ::fidl_next::ValidationError> {
7607 Ok(())
7608 }
7609 }
7610
7611 unsafe impl ::fidl_next::Wire for Capability {
7612 type Narrowed<'de> = Capability;
7613
7614 #[inline]
7615 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7616 ::fidl_next::munge! {
7617 let Self {
7618 id,
7619 offset,
7620
7621 } = &mut *out_;
7622 }
7623
7624 ::fidl_next::Wire::zero_padding(id);
7625
7626 ::fidl_next::Wire::zero_padding(offset);
7627 }
7628 }
7629
7630 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability
7631 where
7632 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7633 {
7634 fn decode(
7635 slot_: ::fidl_next::Slot<'_, Self>,
7636 decoder_: &mut ___D,
7637 _: (),
7638 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7639 ::fidl_next::munge! {
7640 let Self {
7641 mut id,
7642 mut offset,
7643
7644 } = slot_;
7645 }
7646
7647 let _field = id.as_mut();
7648
7649 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7650
7651 let _field = offset.as_mut();
7652
7653 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7654
7655 Ok(())
7656 }
7657 }
7658
7659 impl ::fidl_next::IntoNatural for Capability {
7660 type Natural = crate::natural::Capability;
7661 }
7662
7663 #[derive(Clone, Debug)]
7665 #[repr(C)]
7666 pub struct ExtendedCapability {
7667 pub id: ::fidl_next::wire::Uint16,
7668
7669 pub offset: ::fidl_next::wire::Uint16,
7670 }
7671
7672 static_assertions::const_assert_eq!(std::mem::size_of::<ExtendedCapability>(), 4);
7673 static_assertions::const_assert_eq!(std::mem::align_of::<ExtendedCapability>(), 2);
7674
7675 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, id), 0);
7676
7677 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, offset), 2);
7678
7679 impl ::fidl_next::Constrained for ExtendedCapability {
7680 type Constraint = ();
7681
7682 fn validate(
7683 _: ::fidl_next::Slot<'_, Self>,
7684 _: Self::Constraint,
7685 ) -> Result<(), ::fidl_next::ValidationError> {
7686 Ok(())
7687 }
7688 }
7689
7690 unsafe impl ::fidl_next::Wire for ExtendedCapability {
7691 type Narrowed<'de> = ExtendedCapability;
7692
7693 #[inline]
7694 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7695 ::fidl_next::munge! {
7696 let Self {
7697 id,
7698 offset,
7699
7700 } = &mut *out_;
7701 }
7702
7703 ::fidl_next::Wire::zero_padding(id);
7704
7705 ::fidl_next::Wire::zero_padding(offset);
7706 }
7707 }
7708
7709 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapability
7710 where
7711 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7712 {
7713 fn decode(
7714 slot_: ::fidl_next::Slot<'_, Self>,
7715 decoder_: &mut ___D,
7716 _: (),
7717 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7718 ::fidl_next::munge! {
7719 let Self {
7720 mut id,
7721 mut offset,
7722
7723 } = slot_;
7724 }
7725
7726 let _field = id.as_mut();
7727
7728 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7729
7730 let _field = offset.as_mut();
7731
7732 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7733
7734 Ok(())
7735 }
7736 }
7737
7738 impl ::fidl_next::IntoNatural for ExtendedCapability {
7739 type Natural = crate::natural::ExtendedCapability;
7740 }
7741
7742 #[derive(Debug)]
7744 #[repr(C)]
7745 pub struct PciDevice<'de> {
7746 pub base_addresses: ::fidl_next::wire::Vector<'de, crate::wire::BaseAddress>,
7747
7748 pub capabilities: ::fidl_next::wire::Vector<'de, crate::wire::Capability>,
7749
7750 pub ext_capabilities: ::fidl_next::wire::Vector<'de, crate::wire::ExtendedCapability>,
7751
7752 pub config: ::fidl_next::wire::Vector<'de, u8>,
7753
7754 pub bus_id: u8,
7755
7756 pub device_id: u8,
7757
7758 pub function_id: u8,
7759 }
7760
7761 static_assertions::const_assert_eq!(std::mem::size_of::<PciDevice<'_>>(), 72);
7762 static_assertions::const_assert_eq!(std::mem::align_of::<PciDevice<'_>>(), 8);
7763
7764 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, base_addresses), 0);
7765
7766 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, capabilities), 16);
7767
7768 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, ext_capabilities), 32);
7769
7770 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, config), 48);
7771
7772 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, bus_id), 64);
7773
7774 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, device_id), 65);
7775
7776 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, function_id), 66);
7777
7778 impl ::fidl_next::Constrained for PciDevice<'_> {
7779 type Constraint = ();
7780
7781 fn validate(
7782 _: ::fidl_next::Slot<'_, Self>,
7783 _: Self::Constraint,
7784 ) -> Result<(), ::fidl_next::ValidationError> {
7785 Ok(())
7786 }
7787 }
7788
7789 unsafe impl ::fidl_next::Wire for PciDevice<'static> {
7790 type Narrowed<'de> = PciDevice<'de>;
7791
7792 #[inline]
7793 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7794 ::fidl_next::munge! {
7795 let Self {
7796 base_addresses,
7797 capabilities,
7798 ext_capabilities,
7799 config,
7800 bus_id,
7801 device_id,
7802 function_id,
7803
7804 } = &mut *out_;
7805 }
7806
7807 ::fidl_next::Wire::zero_padding(base_addresses);
7808
7809 ::fidl_next::Wire::zero_padding(capabilities);
7810
7811 ::fidl_next::Wire::zero_padding(ext_capabilities);
7812
7813 ::fidl_next::Wire::zero_padding(config);
7814
7815 ::fidl_next::Wire::zero_padding(bus_id);
7816
7817 ::fidl_next::Wire::zero_padding(device_id);
7818
7819 ::fidl_next::Wire::zero_padding(function_id);
7820
7821 unsafe {
7822 out_.as_mut_ptr().cast::<u8>().add(67).write_bytes(0, 5);
7823 }
7824 }
7825 }
7826
7827 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PciDevice<'de>
7828 where
7829 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7830 ___D: ::fidl_next::Decoder<'de>,
7831 {
7832 fn decode(
7833 slot_: ::fidl_next::Slot<'_, Self>,
7834 decoder_: &mut ___D,
7835 _: (),
7836 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7837 if slot_.as_bytes()[67..72] != [0u8; 5] {
7838 return Err(::fidl_next::DecodeError::InvalidPadding);
7839 }
7840
7841 ::fidl_next::munge! {
7842 let Self {
7843 mut base_addresses,
7844 mut capabilities,
7845 mut ext_capabilities,
7846 mut config,
7847 mut bus_id,
7848 mut device_id,
7849 mut function_id,
7850
7851 } = slot_;
7852 }
7853
7854 let _field = base_addresses.as_mut();
7855 ::fidl_next::Constrained::validate(_field, (6, ()))?;
7856 ::fidl_next::Decode::decode(base_addresses.as_mut(), decoder_, (6, ()))?;
7857
7858 let base_addresses = unsafe { base_addresses.deref_unchecked() };
7859
7860 if base_addresses.len() > 6 {
7861 return Err(::fidl_next::DecodeError::VectorTooLong {
7862 size: base_addresses.len() as u64,
7863 limit: 6,
7864 });
7865 }
7866
7867 let _field = capabilities.as_mut();
7868 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7869 ::fidl_next::Decode::decode(capabilities.as_mut(), decoder_, (32, ()))?;
7870
7871 let capabilities = unsafe { capabilities.deref_unchecked() };
7872
7873 if capabilities.len() > 32 {
7874 return Err(::fidl_next::DecodeError::VectorTooLong {
7875 size: capabilities.len() as u64,
7876 limit: 32,
7877 });
7878 }
7879
7880 let _field = ext_capabilities.as_mut();
7881 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7882 ::fidl_next::Decode::decode(ext_capabilities.as_mut(), decoder_, (32, ()))?;
7883
7884 let ext_capabilities = unsafe { ext_capabilities.deref_unchecked() };
7885
7886 if ext_capabilities.len() > 32 {
7887 return Err(::fidl_next::DecodeError::VectorTooLong {
7888 size: ext_capabilities.len() as u64,
7889 limit: 32,
7890 });
7891 }
7892
7893 let _field = config.as_mut();
7894 ::fidl_next::Constrained::validate(_field, (256, ()))?;
7895 ::fidl_next::Decode::decode(config.as_mut(), decoder_, (256, ()))?;
7896
7897 let config = unsafe { config.deref_unchecked() };
7898
7899 if config.len() > 256 {
7900 return Err(::fidl_next::DecodeError::VectorTooLong {
7901 size: config.len() as u64,
7902 limit: 256,
7903 });
7904 }
7905
7906 let _field = bus_id.as_mut();
7907
7908 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
7909
7910 let _field = device_id.as_mut();
7911
7912 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
7913
7914 let _field = function_id.as_mut();
7915
7916 ::fidl_next::Decode::decode(function_id.as_mut(), decoder_, ())?;
7917
7918 Ok(())
7919 }
7920 }
7921
7922 impl<'de> ::fidl_next::IntoNatural for PciDevice<'de> {
7923 type Natural = crate::natural::PciDevice;
7924 }
7925
7926 #[derive(Debug)]
7928 #[repr(C)]
7929 pub struct BusGetDevicesResponse<'de> {
7930 pub devices: ::fidl_next::wire::Vector<'de, crate::wire::PciDevice<'de>>,
7931 }
7932
7933 static_assertions::const_assert_eq!(std::mem::size_of::<BusGetDevicesResponse<'_>>(), 16);
7934 static_assertions::const_assert_eq!(std::mem::align_of::<BusGetDevicesResponse<'_>>(), 8);
7935
7936 static_assertions::const_assert_eq!(
7937 std::mem::offset_of!(BusGetDevicesResponse<'_>, devices),
7938 0
7939 );
7940
7941 impl ::fidl_next::Constrained for BusGetDevicesResponse<'_> {
7942 type Constraint = ();
7943
7944 fn validate(
7945 _: ::fidl_next::Slot<'_, Self>,
7946 _: Self::Constraint,
7947 ) -> Result<(), ::fidl_next::ValidationError> {
7948 Ok(())
7949 }
7950 }
7951
7952 unsafe impl ::fidl_next::Wire for BusGetDevicesResponse<'static> {
7953 type Narrowed<'de> = BusGetDevicesResponse<'de>;
7954
7955 #[inline]
7956 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7957 ::fidl_next::munge! {
7958 let Self {
7959 devices,
7960
7961 } = &mut *out_;
7962 }
7963
7964 ::fidl_next::Wire::zero_padding(devices);
7965 }
7966 }
7967
7968 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetDevicesResponse<'de>
7969 where
7970 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7971 ___D: ::fidl_next::Decoder<'de>,
7972 {
7973 fn decode(
7974 slot_: ::fidl_next::Slot<'_, Self>,
7975 decoder_: &mut ___D,
7976 _: (),
7977 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7978 ::fidl_next::munge! {
7979 let Self {
7980 mut devices,
7981
7982 } = slot_;
7983 }
7984
7985 let _field = devices.as_mut();
7986 ::fidl_next::Constrained::validate(_field, (64, ()))?;
7987 ::fidl_next::Decode::decode(devices.as_mut(), decoder_, (64, ()))?;
7988
7989 let devices = unsafe { devices.deref_unchecked() };
7990
7991 if devices.len() > 64 {
7992 return Err(::fidl_next::DecodeError::VectorTooLong {
7993 size: devices.len() as u64,
7994 limit: 64,
7995 });
7996 }
7997
7998 Ok(())
7999 }
8000 }
8001
8002 impl<'de> ::fidl_next::IntoNatural for BusGetDevicesResponse<'de> {
8003 type Natural = crate::natural::BusGetDevicesResponse;
8004 }
8005
8006 #[derive(Clone, Debug)]
8008 #[repr(C)]
8009 pub struct BusReadBarRequest {
8010 pub device: crate::wire::Address,
8011
8012 pub bar_id: u8,
8013
8014 pub offset: ::fidl_next::wire::Uint64,
8015
8016 pub size: ::fidl_next::wire::Uint64,
8017 }
8018
8019 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarRequest>(), 24);
8020 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarRequest>(), 8);
8021
8022 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, device), 0);
8023
8024 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, bar_id), 3);
8025
8026 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, offset), 8);
8027
8028 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, size), 16);
8029
8030 impl ::fidl_next::Constrained for BusReadBarRequest {
8031 type Constraint = ();
8032
8033 fn validate(
8034 _: ::fidl_next::Slot<'_, Self>,
8035 _: Self::Constraint,
8036 ) -> Result<(), ::fidl_next::ValidationError> {
8037 Ok(())
8038 }
8039 }
8040
8041 unsafe impl ::fidl_next::Wire for BusReadBarRequest {
8042 type Narrowed<'de> = BusReadBarRequest;
8043
8044 #[inline]
8045 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8046 ::fidl_next::munge! {
8047 let Self {
8048 device,
8049 bar_id,
8050 offset,
8051 size,
8052
8053 } = &mut *out_;
8054 }
8055
8056 ::fidl_next::Wire::zero_padding(device);
8057
8058 ::fidl_next::Wire::zero_padding(bar_id);
8059
8060 ::fidl_next::Wire::zero_padding(offset);
8061
8062 ::fidl_next::Wire::zero_padding(size);
8063
8064 unsafe {
8065 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
8066 }
8067 }
8068 }
8069
8070 unsafe impl<___D> ::fidl_next::Decode<___D> for BusReadBarRequest
8071 where
8072 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8073 {
8074 fn decode(
8075 slot_: ::fidl_next::Slot<'_, Self>,
8076 decoder_: &mut ___D,
8077 _: (),
8078 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8079 if slot_.as_bytes()[4..8] != [0u8; 4] {
8080 return Err(::fidl_next::DecodeError::InvalidPadding);
8081 }
8082
8083 ::fidl_next::munge! {
8084 let Self {
8085 mut device,
8086 mut bar_id,
8087 mut offset,
8088 mut size,
8089
8090 } = slot_;
8091 }
8092
8093 let _field = device.as_mut();
8094
8095 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
8096
8097 let _field = bar_id.as_mut();
8098
8099 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
8100
8101 let _field = offset.as_mut();
8102
8103 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8104
8105 let _field = size.as_mut();
8106
8107 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8108
8109 Ok(())
8110 }
8111 }
8112
8113 impl ::fidl_next::IntoNatural for BusReadBarRequest {
8114 type Natural = crate::natural::BusReadBarRequest;
8115 }
8116
8117 #[derive(Debug)]
8119 #[repr(C)]
8120 pub struct BusReadBarResponse<'de> {
8121 pub buffer: ::fidl_next::wire::Vector<'de, u8>,
8122 }
8123
8124 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarResponse<'_>>(), 16);
8125 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarResponse<'_>>(), 8);
8126
8127 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarResponse<'_>, buffer), 0);
8128
8129 impl ::fidl_next::Constrained for BusReadBarResponse<'_> {
8130 type Constraint = ();
8131
8132 fn validate(
8133 _: ::fidl_next::Slot<'_, Self>,
8134 _: Self::Constraint,
8135 ) -> Result<(), ::fidl_next::ValidationError> {
8136 Ok(())
8137 }
8138 }
8139
8140 unsafe impl ::fidl_next::Wire for BusReadBarResponse<'static> {
8141 type Narrowed<'de> = BusReadBarResponse<'de>;
8142
8143 #[inline]
8144 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8145 ::fidl_next::munge! {
8146 let Self {
8147 buffer,
8148
8149 } = &mut *out_;
8150 }
8151
8152 ::fidl_next::Wire::zero_padding(buffer);
8153 }
8154 }
8155
8156 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusReadBarResponse<'de>
8157 where
8158 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8159 ___D: ::fidl_next::Decoder<'de>,
8160 {
8161 fn decode(
8162 slot_: ::fidl_next::Slot<'_, Self>,
8163 decoder_: &mut ___D,
8164 _: (),
8165 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8166 ::fidl_next::munge! {
8167 let Self {
8168 mut buffer,
8169
8170 } = slot_;
8171 }
8172
8173 let _field = buffer.as_mut();
8174 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
8175 ::fidl_next::Decode::decode(buffer.as_mut(), decoder_, (4294967295, ()))?;
8176
8177 Ok(())
8178 }
8179 }
8180
8181 impl<'de> ::fidl_next::IntoNatural for BusReadBarResponse<'de> {
8182 type Natural = crate::natural::BusReadBarResponse;
8183 }
8184
8185 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8187 #[repr(transparent)]
8188 pub struct CapabilityId {
8189 pub(crate) value: u8,
8190 }
8191
8192 impl ::fidl_next::Constrained for CapabilityId {
8193 type Constraint = ();
8194
8195 fn validate(
8196 _: ::fidl_next::Slot<'_, Self>,
8197 _: Self::Constraint,
8198 ) -> Result<(), ::fidl_next::ValidationError> {
8199 Ok(())
8200 }
8201 }
8202
8203 unsafe impl ::fidl_next::Wire for CapabilityId {
8204 type Narrowed<'de> = Self;
8205
8206 #[inline]
8207 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8208 }
8210 }
8211
8212 impl CapabilityId {
8213 pub const NULL: CapabilityId = CapabilityId { value: 0 };
8214
8215 pub const PCI_PWR_MGMT: CapabilityId = CapabilityId { value: 1 };
8216
8217 pub const AGP: CapabilityId = CapabilityId { value: 2 };
8218
8219 pub const VITAL_PRODUCT_DATA: CapabilityId = CapabilityId { value: 3 };
8220
8221 pub const SLOT_IDENTIFICATION: CapabilityId = CapabilityId { value: 4 };
8222
8223 pub const MSI: CapabilityId = CapabilityId { value: 5 };
8224
8225 pub const COMPACT_PCI_HOTSWAP: CapabilityId = CapabilityId { value: 6 };
8226
8227 pub const PCIX: CapabilityId = CapabilityId { value: 7 };
8228
8229 pub const HYPERTRANSPORT: CapabilityId = CapabilityId { value: 8 };
8230
8231 pub const VENDOR: CapabilityId = CapabilityId { value: 9 };
8232
8233 pub const DEBUG_PORT: CapabilityId = CapabilityId { value: 10 };
8234
8235 pub const COMPACT_PCI_CRC: CapabilityId = CapabilityId { value: 11 };
8236
8237 pub const PCI_HOT_PLUG: CapabilityId = CapabilityId { value: 12 };
8238
8239 pub const PCI_BRIDGE_SUBSYSTEM_VID: CapabilityId = CapabilityId { value: 13 };
8240
8241 pub const AGP8_X: CapabilityId = CapabilityId { value: 14 };
8242
8243 pub const SECURE_DEVICE: CapabilityId = CapabilityId { value: 15 };
8244
8245 pub const PCI_EXPRESS: CapabilityId = CapabilityId { value: 16 };
8246
8247 pub const MSIX: CapabilityId = CapabilityId { value: 17 };
8248
8249 pub const SATA_DATA_NDX_CFG: CapabilityId = CapabilityId { value: 18 };
8250
8251 pub const ADVANCED_FEATURES: CapabilityId = CapabilityId { value: 19 };
8252
8253 pub const ENHANCED_ALLOCATION: CapabilityId = CapabilityId { value: 20 };
8254
8255 pub const FLATTENING_PORTAL_BRIDGE: CapabilityId = CapabilityId { value: 21 };
8256 }
8257
8258 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityId
8259 where
8260 ___D: ?Sized,
8261 {
8262 fn decode(
8263 slot: ::fidl_next::Slot<'_, Self>,
8264 _: &mut ___D,
8265 _: (),
8266 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8267 Ok(())
8268 }
8269 }
8270
8271 impl ::core::convert::From<crate::natural::CapabilityId> for CapabilityId {
8272 fn from(natural: crate::natural::CapabilityId) -> Self {
8273 match natural {
8274 crate::natural::CapabilityId::Null => CapabilityId::NULL,
8275
8276 crate::natural::CapabilityId::PciPwrMgmt => CapabilityId::PCI_PWR_MGMT,
8277
8278 crate::natural::CapabilityId::Agp => CapabilityId::AGP,
8279
8280 crate::natural::CapabilityId::VitalProductData => CapabilityId::VITAL_PRODUCT_DATA,
8281
8282 crate::natural::CapabilityId::SlotIdentification => {
8283 CapabilityId::SLOT_IDENTIFICATION
8284 }
8285
8286 crate::natural::CapabilityId::Msi => CapabilityId::MSI,
8287
8288 crate::natural::CapabilityId::CompactPciHotswap => {
8289 CapabilityId::COMPACT_PCI_HOTSWAP
8290 }
8291
8292 crate::natural::CapabilityId::Pcix => CapabilityId::PCIX,
8293
8294 crate::natural::CapabilityId::Hypertransport => CapabilityId::HYPERTRANSPORT,
8295
8296 crate::natural::CapabilityId::Vendor => CapabilityId::VENDOR,
8297
8298 crate::natural::CapabilityId::DebugPort => CapabilityId::DEBUG_PORT,
8299
8300 crate::natural::CapabilityId::CompactPciCrc => CapabilityId::COMPACT_PCI_CRC,
8301
8302 crate::natural::CapabilityId::PciHotPlug => CapabilityId::PCI_HOT_PLUG,
8303
8304 crate::natural::CapabilityId::PciBridgeSubsystemVid => {
8305 CapabilityId::PCI_BRIDGE_SUBSYSTEM_VID
8306 }
8307
8308 crate::natural::CapabilityId::Agp8X => CapabilityId::AGP8_X,
8309
8310 crate::natural::CapabilityId::SecureDevice => CapabilityId::SECURE_DEVICE,
8311
8312 crate::natural::CapabilityId::PciExpress => CapabilityId::PCI_EXPRESS,
8313
8314 crate::natural::CapabilityId::Msix => CapabilityId::MSIX,
8315
8316 crate::natural::CapabilityId::SataDataNdxCfg => CapabilityId::SATA_DATA_NDX_CFG,
8317
8318 crate::natural::CapabilityId::AdvancedFeatures => CapabilityId::ADVANCED_FEATURES,
8319
8320 crate::natural::CapabilityId::EnhancedAllocation => {
8321 CapabilityId::ENHANCED_ALLOCATION
8322 }
8323
8324 crate::natural::CapabilityId::FlatteningPortalBridge => {
8325 CapabilityId::FLATTENING_PORTAL_BRIDGE
8326 }
8327
8328 crate::natural::CapabilityId::UnknownOrdinal_(value) => {
8329 CapabilityId { value: u8::from(value) }
8330 }
8331 }
8332 }
8333 }
8334
8335 impl ::fidl_next::IntoNatural for CapabilityId {
8336 type Natural = crate::natural::CapabilityId;
8337 }
8338
8339 #[derive(Clone, Copy, Debug)]
8341 #[repr(transparent)]
8342 pub struct Command {
8343 pub(crate) value: ::fidl_next::wire::Uint16,
8344 }
8345
8346 impl ::fidl_next::Constrained for Command {
8347 type Constraint = ();
8348
8349 fn validate(
8350 _: ::fidl_next::Slot<'_, Self>,
8351 _: Self::Constraint,
8352 ) -> Result<(), ::fidl_next::ValidationError> {
8353 Ok(())
8354 }
8355 }
8356
8357 unsafe impl ::fidl_next::Wire for Command {
8358 type Narrowed<'de> = Self;
8359
8360 #[inline]
8361 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8362 }
8364 }
8365
8366 unsafe impl<___D> ::fidl_next::Decode<___D> for Command
8367 where
8368 ___D: ?Sized,
8369 {
8370 fn decode(
8371 slot: ::fidl_next::Slot<'_, Self>,
8372 _: &mut ___D,
8373 _: (),
8374 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8375 Ok(())
8376 }
8377 }
8378
8379 impl ::core::convert::From<crate::natural::Command> for Command {
8380 fn from(natural: crate::natural::Command) -> Self {
8381 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
8382 }
8383 }
8384
8385 impl ::fidl_next::IntoNatural for Command {
8386 type Natural = crate::natural::Command;
8387 }
8388
8389 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8391 #[repr(transparent)]
8392 pub struct Config {
8393 pub(crate) value: ::fidl_next::wire::Uint16,
8394 }
8395
8396 impl ::fidl_next::Constrained for Config {
8397 type Constraint = ();
8398
8399 fn validate(
8400 _: ::fidl_next::Slot<'_, Self>,
8401 _: Self::Constraint,
8402 ) -> Result<(), ::fidl_next::ValidationError> {
8403 Ok(())
8404 }
8405 }
8406
8407 unsafe impl ::fidl_next::Wire for Config {
8408 type Narrowed<'de> = Self;
8409
8410 #[inline]
8411 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8412 }
8414 }
8415
8416 impl Config {
8417 pub const VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(0) };
8418
8419 pub const DEVICE_ID: Config = Config { value: ::fidl_next::wire::Uint16(2) };
8420
8421 pub const COMMAND: Config = Config { value: ::fidl_next::wire::Uint16(4) };
8422
8423 pub const STATUS: Config = Config { value: ::fidl_next::wire::Uint16(6) };
8424
8425 pub const REVISION_ID: Config = Config { value: ::fidl_next::wire::Uint16(8) };
8426
8427 pub const CLASS_CODE_INTR: Config = Config { value: ::fidl_next::wire::Uint16(9) };
8428
8429 pub const CLASS_CODE_SUB: Config = Config { value: ::fidl_next::wire::Uint16(10) };
8430
8431 pub const CLASS_CODE_BASE: Config = Config { value: ::fidl_next::wire::Uint16(11) };
8432
8433 pub const CACHE_LINE_SIZE: Config = Config { value: ::fidl_next::wire::Uint16(12) };
8434
8435 pub const LATENCY_TIMER: Config = Config { value: ::fidl_next::wire::Uint16(13) };
8436
8437 pub const HEADER_TYPE: Config = Config { value: ::fidl_next::wire::Uint16(14) };
8438
8439 pub const BIST: Config = Config { value: ::fidl_next::wire::Uint16(15) };
8440
8441 pub const BASE_ADDRESSES: Config = Config { value: ::fidl_next::wire::Uint16(16) };
8442
8443 pub const CARDBUS_CIS_PTR: Config = Config { value: ::fidl_next::wire::Uint16(40) };
8444
8445 pub const SUBSYSTEM_VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(44) };
8446
8447 pub const SUBSYSTEM_ID: Config = Config { value: ::fidl_next::wire::Uint16(46) };
8448
8449 pub const EXP_ROM_ADDRESS: Config = Config { value: ::fidl_next::wire::Uint16(48) };
8450
8451 pub const CAPABILITIES_PTR: Config = Config { value: ::fidl_next::wire::Uint16(52) };
8452
8453 pub const INTERRUPT_LINE: Config = Config { value: ::fidl_next::wire::Uint16(60) };
8454
8455 pub const INTERRUPT_PIN: Config = Config { value: ::fidl_next::wire::Uint16(61) };
8456
8457 pub const MIN_GRANT: Config = Config { value: ::fidl_next::wire::Uint16(62) };
8458
8459 pub const MAX_LATENCY: Config = Config { value: ::fidl_next::wire::Uint16(63) };
8460 }
8461
8462 unsafe impl<___D> ::fidl_next::Decode<___D> for Config
8463 where
8464 ___D: ?Sized,
8465 {
8466 fn decode(
8467 slot: ::fidl_next::Slot<'_, Self>,
8468 _: &mut ___D,
8469 _: (),
8470 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8471 Ok(())
8472 }
8473 }
8474
8475 impl ::core::convert::From<crate::natural::Config> for Config {
8476 fn from(natural: crate::natural::Config) -> Self {
8477 match natural {
8478 crate::natural::Config::VendorId => Config::VENDOR_ID,
8479
8480 crate::natural::Config::DeviceId => Config::DEVICE_ID,
8481
8482 crate::natural::Config::Command => Config::COMMAND,
8483
8484 crate::natural::Config::Status => Config::STATUS,
8485
8486 crate::natural::Config::RevisionId => Config::REVISION_ID,
8487
8488 crate::natural::Config::ClassCodeIntr => Config::CLASS_CODE_INTR,
8489
8490 crate::natural::Config::ClassCodeSub => Config::CLASS_CODE_SUB,
8491
8492 crate::natural::Config::ClassCodeBase => Config::CLASS_CODE_BASE,
8493
8494 crate::natural::Config::CacheLineSize => Config::CACHE_LINE_SIZE,
8495
8496 crate::natural::Config::LatencyTimer => Config::LATENCY_TIMER,
8497
8498 crate::natural::Config::HeaderType => Config::HEADER_TYPE,
8499
8500 crate::natural::Config::Bist => Config::BIST,
8501
8502 crate::natural::Config::BaseAddresses => Config::BASE_ADDRESSES,
8503
8504 crate::natural::Config::CardbusCisPtr => Config::CARDBUS_CIS_PTR,
8505
8506 crate::natural::Config::SubsystemVendorId => Config::SUBSYSTEM_VENDOR_ID,
8507
8508 crate::natural::Config::SubsystemId => Config::SUBSYSTEM_ID,
8509
8510 crate::natural::Config::ExpRomAddress => Config::EXP_ROM_ADDRESS,
8511
8512 crate::natural::Config::CapabilitiesPtr => Config::CAPABILITIES_PTR,
8513
8514 crate::natural::Config::InterruptLine => Config::INTERRUPT_LINE,
8515
8516 crate::natural::Config::InterruptPin => Config::INTERRUPT_PIN,
8517
8518 crate::natural::Config::MinGrant => Config::MIN_GRANT,
8519
8520 crate::natural::Config::MaxLatency => Config::MAX_LATENCY,
8521
8522 crate::natural::Config::UnknownOrdinal_(value) => {
8523 Config { value: ::fidl_next::wire::Uint16::from(value) }
8524 }
8525 }
8526 }
8527 }
8528
8529 impl ::fidl_next::IntoNatural for Config {
8530 type Natural = crate::natural::Config;
8531 }
8532
8533 pub type ConfigOffset = u8;
8535
8536 pub type Padding = ::fidl_next::wire::Unit;
8538
8539 #[derive(Clone, Debug)]
8541 #[repr(C)]
8542 pub struct DeviceInfo {
8543 pub vendor_id: ::fidl_next::wire::Uint16,
8544
8545 pub device_id: ::fidl_next::wire::Uint16,
8546
8547 pub base_class: u8,
8548
8549 pub sub_class: u8,
8550
8551 pub program_interface: u8,
8552
8553 pub revision_id: u8,
8554
8555 pub bus_id: u8,
8556
8557 pub dev_id: u8,
8558
8559 pub func_id: u8,
8560
8561 pub padding: crate::wire::Padding,
8562 }
8563
8564 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceInfo>(), 12);
8565 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceInfo>(), 2);
8566
8567 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, vendor_id), 0);
8568
8569 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, device_id), 2);
8570
8571 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, base_class), 4);
8572
8573 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, sub_class), 5);
8574
8575 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, program_interface), 6);
8576
8577 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, revision_id), 7);
8578
8579 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, bus_id), 8);
8580
8581 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, dev_id), 9);
8582
8583 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, func_id), 10);
8584
8585 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, padding), 11);
8586
8587 impl ::fidl_next::Constrained for DeviceInfo {
8588 type Constraint = ();
8589
8590 fn validate(
8591 _: ::fidl_next::Slot<'_, Self>,
8592 _: Self::Constraint,
8593 ) -> Result<(), ::fidl_next::ValidationError> {
8594 Ok(())
8595 }
8596 }
8597
8598 unsafe impl ::fidl_next::Wire for DeviceInfo {
8599 type Narrowed<'de> = DeviceInfo;
8600
8601 #[inline]
8602 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8603 ::fidl_next::munge! {
8604 let Self {
8605 vendor_id,
8606 device_id,
8607 base_class,
8608 sub_class,
8609 program_interface,
8610 revision_id,
8611 bus_id,
8612 dev_id,
8613 func_id,
8614 padding,
8615
8616 } = &mut *out_;
8617 }
8618
8619 ::fidl_next::Wire::zero_padding(vendor_id);
8620
8621 ::fidl_next::Wire::zero_padding(device_id);
8622
8623 ::fidl_next::Wire::zero_padding(base_class);
8624
8625 ::fidl_next::Wire::zero_padding(sub_class);
8626
8627 ::fidl_next::Wire::zero_padding(program_interface);
8628
8629 ::fidl_next::Wire::zero_padding(revision_id);
8630
8631 ::fidl_next::Wire::zero_padding(bus_id);
8632
8633 ::fidl_next::Wire::zero_padding(dev_id);
8634
8635 ::fidl_next::Wire::zero_padding(func_id);
8636
8637 ::fidl_next::Wire::zero_padding(padding);
8638 }
8639 }
8640
8641 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceInfo
8642 where
8643 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8644 {
8645 fn decode(
8646 slot_: ::fidl_next::Slot<'_, Self>,
8647 decoder_: &mut ___D,
8648 _: (),
8649 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8650 ::fidl_next::munge! {
8651 let Self {
8652 mut vendor_id,
8653 mut device_id,
8654 mut base_class,
8655 mut sub_class,
8656 mut program_interface,
8657 mut revision_id,
8658 mut bus_id,
8659 mut dev_id,
8660 mut func_id,
8661 mut padding,
8662
8663 } = slot_;
8664 }
8665
8666 let _field = vendor_id.as_mut();
8667
8668 ::fidl_next::Decode::decode(vendor_id.as_mut(), decoder_, ())?;
8669
8670 let _field = device_id.as_mut();
8671
8672 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
8673
8674 let _field = base_class.as_mut();
8675
8676 ::fidl_next::Decode::decode(base_class.as_mut(), decoder_, ())?;
8677
8678 let _field = sub_class.as_mut();
8679
8680 ::fidl_next::Decode::decode(sub_class.as_mut(), decoder_, ())?;
8681
8682 let _field = program_interface.as_mut();
8683
8684 ::fidl_next::Decode::decode(program_interface.as_mut(), decoder_, ())?;
8685
8686 let _field = revision_id.as_mut();
8687
8688 ::fidl_next::Decode::decode(revision_id.as_mut(), decoder_, ())?;
8689
8690 let _field = bus_id.as_mut();
8691
8692 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
8693
8694 let _field = dev_id.as_mut();
8695
8696 ::fidl_next::Decode::decode(dev_id.as_mut(), decoder_, ())?;
8697
8698 let _field = func_id.as_mut();
8699
8700 ::fidl_next::Decode::decode(func_id.as_mut(), decoder_, ())?;
8701
8702 let _field = padding.as_mut();
8703
8704 ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
8705
8706 Ok(())
8707 }
8708 }
8709
8710 impl ::fidl_next::IntoNatural for DeviceInfo {
8711 type Natural = crate::natural::DeviceInfo;
8712 }
8713
8714 #[derive(Clone, Debug)]
8716 #[repr(C)]
8717 pub struct DeviceGetDeviceInfoResponse {
8718 pub info: crate::wire::DeviceInfo,
8719 }
8720
8721 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetDeviceInfoResponse>(), 12);
8722 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetDeviceInfoResponse>(), 2);
8723
8724 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetDeviceInfoResponse, info), 0);
8725
8726 impl ::fidl_next::Constrained for DeviceGetDeviceInfoResponse {
8727 type Constraint = ();
8728
8729 fn validate(
8730 _: ::fidl_next::Slot<'_, Self>,
8731 _: Self::Constraint,
8732 ) -> Result<(), ::fidl_next::ValidationError> {
8733 Ok(())
8734 }
8735 }
8736
8737 unsafe impl ::fidl_next::Wire for DeviceGetDeviceInfoResponse {
8738 type Narrowed<'de> = DeviceGetDeviceInfoResponse;
8739
8740 #[inline]
8741 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8742 ::fidl_next::munge! {
8743 let Self {
8744 info,
8745
8746 } = &mut *out_;
8747 }
8748
8749 ::fidl_next::Wire::zero_padding(info);
8750 }
8751 }
8752
8753 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetDeviceInfoResponse
8754 where
8755 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8756 {
8757 fn decode(
8758 slot_: ::fidl_next::Slot<'_, Self>,
8759 decoder_: &mut ___D,
8760 _: (),
8761 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8762 ::fidl_next::munge! {
8763 let Self {
8764 mut info,
8765
8766 } = slot_;
8767 }
8768
8769 let _field = info.as_mut();
8770
8771 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
8772
8773 Ok(())
8774 }
8775 }
8776
8777 impl ::fidl_next::IntoNatural for DeviceGetDeviceInfoResponse {
8778 type Natural = crate::natural::DeviceGetDeviceInfoResponse;
8779 }
8780
8781 #[derive(Clone, Debug)]
8783 #[repr(C)]
8784 pub struct DeviceGetBarRequest {
8785 pub bar_id: ::fidl_next::wire::Uint32,
8786 }
8787
8788 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBarRequest>(), 4);
8789 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBarRequest>(), 4);
8790
8791 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBarRequest, bar_id), 0);
8792
8793 impl ::fidl_next::Constrained for DeviceGetBarRequest {
8794 type Constraint = ();
8795
8796 fn validate(
8797 _: ::fidl_next::Slot<'_, Self>,
8798 _: Self::Constraint,
8799 ) -> Result<(), ::fidl_next::ValidationError> {
8800 Ok(())
8801 }
8802 }
8803
8804 unsafe impl ::fidl_next::Wire for DeviceGetBarRequest {
8805 type Narrowed<'de> = DeviceGetBarRequest;
8806
8807 #[inline]
8808 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8809 ::fidl_next::munge! {
8810 let Self {
8811 bar_id,
8812
8813 } = &mut *out_;
8814 }
8815
8816 ::fidl_next::Wire::zero_padding(bar_id);
8817 }
8818 }
8819
8820 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBarRequest
8821 where
8822 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8823 {
8824 fn decode(
8825 slot_: ::fidl_next::Slot<'_, Self>,
8826 decoder_: &mut ___D,
8827 _: (),
8828 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8829 ::fidl_next::munge! {
8830 let Self {
8831 mut bar_id,
8832
8833 } = slot_;
8834 }
8835
8836 let _field = bar_id.as_mut();
8837
8838 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
8839
8840 Ok(())
8841 }
8842 }
8843
8844 impl ::fidl_next::IntoNatural for DeviceGetBarRequest {
8845 type Natural = crate::natural::DeviceGetBarRequest;
8846 }
8847
8848 #[derive(Clone, Debug)]
8850 #[repr(C)]
8851 pub struct DeviceSetBusMasteringRequest {
8852 pub enabled: bool,
8853 }
8854
8855 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetBusMasteringRequest>(), 1);
8856 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetBusMasteringRequest>(), 1);
8857
8858 static_assertions::const_assert_eq!(
8859 std::mem::offset_of!(DeviceSetBusMasteringRequest, enabled),
8860 0
8861 );
8862
8863 impl ::fidl_next::Constrained for DeviceSetBusMasteringRequest {
8864 type Constraint = ();
8865
8866 fn validate(
8867 _: ::fidl_next::Slot<'_, Self>,
8868 _: Self::Constraint,
8869 ) -> Result<(), ::fidl_next::ValidationError> {
8870 Ok(())
8871 }
8872 }
8873
8874 unsafe impl ::fidl_next::Wire for DeviceSetBusMasteringRequest {
8875 type Narrowed<'de> = DeviceSetBusMasteringRequest;
8876
8877 #[inline]
8878 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8879 ::fidl_next::munge! {
8880 let Self {
8881 enabled,
8882
8883 } = &mut *out_;
8884 }
8885
8886 ::fidl_next::Wire::zero_padding(enabled);
8887 }
8888 }
8889
8890 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetBusMasteringRequest
8891 where
8892 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8893 {
8894 fn decode(
8895 slot_: ::fidl_next::Slot<'_, Self>,
8896 decoder_: &mut ___D,
8897 _: (),
8898 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8899 ::fidl_next::munge! {
8900 let Self {
8901 mut enabled,
8902
8903 } = slot_;
8904 }
8905
8906 let _field = enabled.as_mut();
8907
8908 ::fidl_next::Decode::decode(enabled.as_mut(), decoder_, ())?;
8909
8910 Ok(())
8911 }
8912 }
8913
8914 impl ::fidl_next::IntoNatural for DeviceSetBusMasteringRequest {
8915 type Natural = crate::natural::DeviceSetBusMasteringRequest;
8916 }
8917
8918 pub type DeviceSetBusMasteringResponse = ::fidl_next::wire::Unit;
8920
8921 pub type DeviceResetDeviceResponse = ::fidl_next::wire::Unit;
8923
8924 pub type DeviceAckInterruptResponse = ::fidl_next::wire::Unit;
8926
8927 #[derive(Clone, Debug)]
8929 #[repr(C)]
8930 pub struct DeviceMapInterruptRequest {
8931 pub which_irq: ::fidl_next::wire::Uint32,
8932 }
8933
8934 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceMapInterruptRequest>(), 4);
8935 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceMapInterruptRequest>(), 4);
8936
8937 static_assertions::const_assert_eq!(
8938 std::mem::offset_of!(DeviceMapInterruptRequest, which_irq),
8939 0
8940 );
8941
8942 impl ::fidl_next::Constrained for DeviceMapInterruptRequest {
8943 type Constraint = ();
8944
8945 fn validate(
8946 _: ::fidl_next::Slot<'_, Self>,
8947 _: Self::Constraint,
8948 ) -> Result<(), ::fidl_next::ValidationError> {
8949 Ok(())
8950 }
8951 }
8952
8953 unsafe impl ::fidl_next::Wire for DeviceMapInterruptRequest {
8954 type Narrowed<'de> = DeviceMapInterruptRequest;
8955
8956 #[inline]
8957 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8958 ::fidl_next::munge! {
8959 let Self {
8960 which_irq,
8961
8962 } = &mut *out_;
8963 }
8964
8965 ::fidl_next::Wire::zero_padding(which_irq);
8966 }
8967 }
8968
8969 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceMapInterruptRequest
8970 where
8971 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8972 {
8973 fn decode(
8974 slot_: ::fidl_next::Slot<'_, Self>,
8975 decoder_: &mut ___D,
8976 _: (),
8977 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8978 ::fidl_next::munge! {
8979 let Self {
8980 mut which_irq,
8981
8982 } = slot_;
8983 }
8984
8985 let _field = which_irq.as_mut();
8986
8987 ::fidl_next::Decode::decode(which_irq.as_mut(), decoder_, ())?;
8988
8989 Ok(())
8990 }
8991 }
8992
8993 impl ::fidl_next::IntoNatural for DeviceMapInterruptRequest {
8994 type Natural = crate::natural::DeviceMapInterruptRequest;
8995 }
8996
8997 #[derive(Clone, Debug)]
8999 #[repr(C)]
9000 pub struct InterruptModes {
9001 pub has_legacy: bool,
9002
9003 pub msi_count: u8,
9004
9005 pub msix_count: ::fidl_next::wire::Uint16,
9006 }
9007
9008 static_assertions::const_assert_eq!(std::mem::size_of::<InterruptModes>(), 4);
9009 static_assertions::const_assert_eq!(std::mem::align_of::<InterruptModes>(), 2);
9010
9011 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, has_legacy), 0);
9012
9013 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msi_count), 1);
9014
9015 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msix_count), 2);
9016
9017 impl ::fidl_next::Constrained for InterruptModes {
9018 type Constraint = ();
9019
9020 fn validate(
9021 _: ::fidl_next::Slot<'_, Self>,
9022 _: Self::Constraint,
9023 ) -> Result<(), ::fidl_next::ValidationError> {
9024 Ok(())
9025 }
9026 }
9027
9028 unsafe impl ::fidl_next::Wire for InterruptModes {
9029 type Narrowed<'de> = InterruptModes;
9030
9031 #[inline]
9032 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9033 ::fidl_next::munge! {
9034 let Self {
9035 has_legacy,
9036 msi_count,
9037 msix_count,
9038
9039 } = &mut *out_;
9040 }
9041
9042 ::fidl_next::Wire::zero_padding(has_legacy);
9043
9044 ::fidl_next::Wire::zero_padding(msi_count);
9045
9046 ::fidl_next::Wire::zero_padding(msix_count);
9047 }
9048 }
9049
9050 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptModes
9051 where
9052 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9053 {
9054 fn decode(
9055 slot_: ::fidl_next::Slot<'_, Self>,
9056 decoder_: &mut ___D,
9057 _: (),
9058 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9059 ::fidl_next::munge! {
9060 let Self {
9061 mut has_legacy,
9062 mut msi_count,
9063 mut msix_count,
9064
9065 } = slot_;
9066 }
9067
9068 let _field = has_legacy.as_mut();
9069
9070 ::fidl_next::Decode::decode(has_legacy.as_mut(), decoder_, ())?;
9071
9072 let _field = msi_count.as_mut();
9073
9074 ::fidl_next::Decode::decode(msi_count.as_mut(), decoder_, ())?;
9075
9076 let _field = msix_count.as_mut();
9077
9078 ::fidl_next::Decode::decode(msix_count.as_mut(), decoder_, ())?;
9079
9080 Ok(())
9081 }
9082 }
9083
9084 impl ::fidl_next::IntoNatural for InterruptModes {
9085 type Natural = crate::natural::InterruptModes;
9086 }
9087
9088 #[derive(Clone, Debug)]
9090 #[repr(C)]
9091 pub struct DeviceGetInterruptModesResponse {
9092 pub modes: crate::wire::InterruptModes,
9093 }
9094
9095 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetInterruptModesResponse>(), 4);
9096 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetInterruptModesResponse>(), 2);
9097
9098 static_assertions::const_assert_eq!(
9099 std::mem::offset_of!(DeviceGetInterruptModesResponse, modes),
9100 0
9101 );
9102
9103 impl ::fidl_next::Constrained for DeviceGetInterruptModesResponse {
9104 type Constraint = ();
9105
9106 fn validate(
9107 _: ::fidl_next::Slot<'_, Self>,
9108 _: Self::Constraint,
9109 ) -> Result<(), ::fidl_next::ValidationError> {
9110 Ok(())
9111 }
9112 }
9113
9114 unsafe impl ::fidl_next::Wire for DeviceGetInterruptModesResponse {
9115 type Narrowed<'de> = DeviceGetInterruptModesResponse;
9116
9117 #[inline]
9118 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9119 ::fidl_next::munge! {
9120 let Self {
9121 modes,
9122
9123 } = &mut *out_;
9124 }
9125
9126 ::fidl_next::Wire::zero_padding(modes);
9127 }
9128 }
9129
9130 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetInterruptModesResponse
9131 where
9132 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9133 {
9134 fn decode(
9135 slot_: ::fidl_next::Slot<'_, Self>,
9136 decoder_: &mut ___D,
9137 _: (),
9138 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9139 ::fidl_next::munge! {
9140 let Self {
9141 mut modes,
9142
9143 } = slot_;
9144 }
9145
9146 let _field = modes.as_mut();
9147
9148 ::fidl_next::Decode::decode(modes.as_mut(), decoder_, ())?;
9149
9150 Ok(())
9151 }
9152 }
9153
9154 impl ::fidl_next::IntoNatural for DeviceGetInterruptModesResponse {
9155 type Natural = crate::natural::DeviceGetInterruptModesResponse;
9156 }
9157
9158 pub type DeviceSetInterruptModeResponse = ::fidl_next::wire::Unit;
9160
9161 pub type ExtendedConfigOffset = ::fidl_next::wire::Uint16;
9163
9164 #[derive(Clone, Debug)]
9166 #[repr(C)]
9167 pub struct DeviceReadConfig8Request {
9168 pub offset: ::fidl_next::wire::Uint16,
9169 }
9170
9171 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Request>(), 2);
9172 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Request>(), 2);
9173
9174 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Request, offset), 0);
9175
9176 impl ::fidl_next::Constrained for DeviceReadConfig8Request {
9177 type Constraint = ();
9178
9179 fn validate(
9180 _: ::fidl_next::Slot<'_, Self>,
9181 _: Self::Constraint,
9182 ) -> Result<(), ::fidl_next::ValidationError> {
9183 Ok(())
9184 }
9185 }
9186
9187 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Request {
9188 type Narrowed<'de> = DeviceReadConfig8Request;
9189
9190 #[inline]
9191 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9192 ::fidl_next::munge! {
9193 let Self {
9194 offset,
9195
9196 } = &mut *out_;
9197 }
9198
9199 ::fidl_next::Wire::zero_padding(offset);
9200 }
9201 }
9202
9203 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Request
9204 where
9205 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9206 {
9207 fn decode(
9208 slot_: ::fidl_next::Slot<'_, Self>,
9209 decoder_: &mut ___D,
9210 _: (),
9211 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9212 ::fidl_next::munge! {
9213 let Self {
9214 mut offset,
9215
9216 } = slot_;
9217 }
9218
9219 let _field = offset.as_mut();
9220
9221 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9222
9223 Ok(())
9224 }
9225 }
9226
9227 impl ::fidl_next::IntoNatural for DeviceReadConfig8Request {
9228 type Natural = crate::natural::DeviceReadConfig8Request;
9229 }
9230
9231 #[derive(Clone, Debug)]
9233 #[repr(C)]
9234 pub struct DeviceReadConfig8Response {
9235 pub value: u8,
9236 }
9237
9238 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Response>(), 1);
9239 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Response>(), 1);
9240
9241 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Response, value), 0);
9242
9243 impl ::fidl_next::Constrained for DeviceReadConfig8Response {
9244 type Constraint = ();
9245
9246 fn validate(
9247 _: ::fidl_next::Slot<'_, Self>,
9248 _: Self::Constraint,
9249 ) -> Result<(), ::fidl_next::ValidationError> {
9250 Ok(())
9251 }
9252 }
9253
9254 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Response {
9255 type Narrowed<'de> = DeviceReadConfig8Response;
9256
9257 #[inline]
9258 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9259 ::fidl_next::munge! {
9260 let Self {
9261 value,
9262
9263 } = &mut *out_;
9264 }
9265
9266 ::fidl_next::Wire::zero_padding(value);
9267 }
9268 }
9269
9270 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Response
9271 where
9272 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9273 {
9274 fn decode(
9275 slot_: ::fidl_next::Slot<'_, Self>,
9276 decoder_: &mut ___D,
9277 _: (),
9278 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9279 ::fidl_next::munge! {
9280 let Self {
9281 mut value,
9282
9283 } = slot_;
9284 }
9285
9286 let _field = value.as_mut();
9287
9288 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9289
9290 Ok(())
9291 }
9292 }
9293
9294 impl ::fidl_next::IntoNatural for DeviceReadConfig8Response {
9295 type Natural = crate::natural::DeviceReadConfig8Response;
9296 }
9297
9298 #[derive(Clone, Debug)]
9300 #[repr(C)]
9301 pub struct DeviceReadConfig16Request {
9302 pub offset: ::fidl_next::wire::Uint16,
9303 }
9304
9305 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Request>(), 2);
9306 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Request>(), 2);
9307
9308 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Request, offset), 0);
9309
9310 impl ::fidl_next::Constrained for DeviceReadConfig16Request {
9311 type Constraint = ();
9312
9313 fn validate(
9314 _: ::fidl_next::Slot<'_, Self>,
9315 _: Self::Constraint,
9316 ) -> Result<(), ::fidl_next::ValidationError> {
9317 Ok(())
9318 }
9319 }
9320
9321 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Request {
9322 type Narrowed<'de> = DeviceReadConfig16Request;
9323
9324 #[inline]
9325 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9326 ::fidl_next::munge! {
9327 let Self {
9328 offset,
9329
9330 } = &mut *out_;
9331 }
9332
9333 ::fidl_next::Wire::zero_padding(offset);
9334 }
9335 }
9336
9337 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Request
9338 where
9339 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9340 {
9341 fn decode(
9342 slot_: ::fidl_next::Slot<'_, Self>,
9343 decoder_: &mut ___D,
9344 _: (),
9345 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9346 ::fidl_next::munge! {
9347 let Self {
9348 mut offset,
9349
9350 } = slot_;
9351 }
9352
9353 let _field = offset.as_mut();
9354
9355 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9356
9357 Ok(())
9358 }
9359 }
9360
9361 impl ::fidl_next::IntoNatural for DeviceReadConfig16Request {
9362 type Natural = crate::natural::DeviceReadConfig16Request;
9363 }
9364
9365 #[derive(Clone, Debug)]
9367 #[repr(C)]
9368 pub struct DeviceReadConfig16Response {
9369 pub value: ::fidl_next::wire::Uint16,
9370 }
9371
9372 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Response>(), 2);
9373 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Response>(), 2);
9374
9375 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Response, value), 0);
9376
9377 impl ::fidl_next::Constrained for DeviceReadConfig16Response {
9378 type Constraint = ();
9379
9380 fn validate(
9381 _: ::fidl_next::Slot<'_, Self>,
9382 _: Self::Constraint,
9383 ) -> Result<(), ::fidl_next::ValidationError> {
9384 Ok(())
9385 }
9386 }
9387
9388 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Response {
9389 type Narrowed<'de> = DeviceReadConfig16Response;
9390
9391 #[inline]
9392 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9393 ::fidl_next::munge! {
9394 let Self {
9395 value,
9396
9397 } = &mut *out_;
9398 }
9399
9400 ::fidl_next::Wire::zero_padding(value);
9401 }
9402 }
9403
9404 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Response
9405 where
9406 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9407 {
9408 fn decode(
9409 slot_: ::fidl_next::Slot<'_, Self>,
9410 decoder_: &mut ___D,
9411 _: (),
9412 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9413 ::fidl_next::munge! {
9414 let Self {
9415 mut value,
9416
9417 } = slot_;
9418 }
9419
9420 let _field = value.as_mut();
9421
9422 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9423
9424 Ok(())
9425 }
9426 }
9427
9428 impl ::fidl_next::IntoNatural for DeviceReadConfig16Response {
9429 type Natural = crate::natural::DeviceReadConfig16Response;
9430 }
9431
9432 #[derive(Clone, Debug)]
9434 #[repr(C)]
9435 pub struct DeviceReadConfig32Request {
9436 pub offset: ::fidl_next::wire::Uint16,
9437 }
9438
9439 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Request>(), 2);
9440 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Request>(), 2);
9441
9442 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Request, offset), 0);
9443
9444 impl ::fidl_next::Constrained for DeviceReadConfig32Request {
9445 type Constraint = ();
9446
9447 fn validate(
9448 _: ::fidl_next::Slot<'_, Self>,
9449 _: Self::Constraint,
9450 ) -> Result<(), ::fidl_next::ValidationError> {
9451 Ok(())
9452 }
9453 }
9454
9455 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Request {
9456 type Narrowed<'de> = DeviceReadConfig32Request;
9457
9458 #[inline]
9459 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9460 ::fidl_next::munge! {
9461 let Self {
9462 offset,
9463
9464 } = &mut *out_;
9465 }
9466
9467 ::fidl_next::Wire::zero_padding(offset);
9468 }
9469 }
9470
9471 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Request
9472 where
9473 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9474 {
9475 fn decode(
9476 slot_: ::fidl_next::Slot<'_, Self>,
9477 decoder_: &mut ___D,
9478 _: (),
9479 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9480 ::fidl_next::munge! {
9481 let Self {
9482 mut offset,
9483
9484 } = slot_;
9485 }
9486
9487 let _field = offset.as_mut();
9488
9489 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9490
9491 Ok(())
9492 }
9493 }
9494
9495 impl ::fidl_next::IntoNatural for DeviceReadConfig32Request {
9496 type Natural = crate::natural::DeviceReadConfig32Request;
9497 }
9498
9499 #[derive(Clone, Debug)]
9501 #[repr(C)]
9502 pub struct DeviceReadConfig32Response {
9503 pub value: ::fidl_next::wire::Uint32,
9504 }
9505
9506 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Response>(), 4);
9507 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Response>(), 4);
9508
9509 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Response, value), 0);
9510
9511 impl ::fidl_next::Constrained for DeviceReadConfig32Response {
9512 type Constraint = ();
9513
9514 fn validate(
9515 _: ::fidl_next::Slot<'_, Self>,
9516 _: Self::Constraint,
9517 ) -> Result<(), ::fidl_next::ValidationError> {
9518 Ok(())
9519 }
9520 }
9521
9522 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Response {
9523 type Narrowed<'de> = DeviceReadConfig32Response;
9524
9525 #[inline]
9526 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9527 ::fidl_next::munge! {
9528 let Self {
9529 value,
9530
9531 } = &mut *out_;
9532 }
9533
9534 ::fidl_next::Wire::zero_padding(value);
9535 }
9536 }
9537
9538 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Response
9539 where
9540 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9541 {
9542 fn decode(
9543 slot_: ::fidl_next::Slot<'_, Self>,
9544 decoder_: &mut ___D,
9545 _: (),
9546 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9547 ::fidl_next::munge! {
9548 let Self {
9549 mut value,
9550
9551 } = slot_;
9552 }
9553
9554 let _field = value.as_mut();
9555
9556 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9557
9558 Ok(())
9559 }
9560 }
9561
9562 impl ::fidl_next::IntoNatural for DeviceReadConfig32Response {
9563 type Natural = crate::natural::DeviceReadConfig32Response;
9564 }
9565
9566 #[derive(Clone, Debug)]
9568 #[repr(C)]
9569 pub struct DeviceWriteConfig8Request {
9570 pub offset: ::fidl_next::wire::Uint16,
9571
9572 pub value: u8,
9573 }
9574
9575 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig8Request>(), 4);
9576 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig8Request>(), 2);
9577
9578 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, offset), 0);
9579
9580 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, value), 2);
9581
9582 impl ::fidl_next::Constrained for DeviceWriteConfig8Request {
9583 type Constraint = ();
9584
9585 fn validate(
9586 _: ::fidl_next::Slot<'_, Self>,
9587 _: Self::Constraint,
9588 ) -> Result<(), ::fidl_next::ValidationError> {
9589 Ok(())
9590 }
9591 }
9592
9593 unsafe impl ::fidl_next::Wire for DeviceWriteConfig8Request {
9594 type Narrowed<'de> = DeviceWriteConfig8Request;
9595
9596 #[inline]
9597 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9598 ::fidl_next::munge! {
9599 let Self {
9600 offset,
9601 value,
9602
9603 } = &mut *out_;
9604 }
9605
9606 ::fidl_next::Wire::zero_padding(offset);
9607
9608 ::fidl_next::Wire::zero_padding(value);
9609
9610 unsafe {
9611 out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 1);
9612 }
9613 }
9614 }
9615
9616 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig8Request
9617 where
9618 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9619 {
9620 fn decode(
9621 slot_: ::fidl_next::Slot<'_, Self>,
9622 decoder_: &mut ___D,
9623 _: (),
9624 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9625 if slot_.as_bytes()[3..4] != [0u8; 1] {
9626 return Err(::fidl_next::DecodeError::InvalidPadding);
9627 }
9628
9629 ::fidl_next::munge! {
9630 let Self {
9631 mut offset,
9632 mut value,
9633
9634 } = slot_;
9635 }
9636
9637 let _field = offset.as_mut();
9638
9639 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9640
9641 let _field = value.as_mut();
9642
9643 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9644
9645 Ok(())
9646 }
9647 }
9648
9649 impl ::fidl_next::IntoNatural for DeviceWriteConfig8Request {
9650 type Natural = crate::natural::DeviceWriteConfig8Request;
9651 }
9652
9653 pub type DeviceWriteConfig8Response = ::fidl_next::wire::Unit;
9655
9656 #[derive(Clone, Debug)]
9658 #[repr(C)]
9659 pub struct DeviceWriteConfig16Request {
9660 pub offset: ::fidl_next::wire::Uint16,
9661
9662 pub value: ::fidl_next::wire::Uint16,
9663 }
9664
9665 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig16Request>(), 4);
9666 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig16Request>(), 2);
9667
9668 static_assertions::const_assert_eq!(
9669 std::mem::offset_of!(DeviceWriteConfig16Request, offset),
9670 0
9671 );
9672
9673 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig16Request, value), 2);
9674
9675 impl ::fidl_next::Constrained for DeviceWriteConfig16Request {
9676 type Constraint = ();
9677
9678 fn validate(
9679 _: ::fidl_next::Slot<'_, Self>,
9680 _: Self::Constraint,
9681 ) -> Result<(), ::fidl_next::ValidationError> {
9682 Ok(())
9683 }
9684 }
9685
9686 unsafe impl ::fidl_next::Wire for DeviceWriteConfig16Request {
9687 type Narrowed<'de> = DeviceWriteConfig16Request;
9688
9689 #[inline]
9690 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9691 ::fidl_next::munge! {
9692 let Self {
9693 offset,
9694 value,
9695
9696 } = &mut *out_;
9697 }
9698
9699 ::fidl_next::Wire::zero_padding(offset);
9700
9701 ::fidl_next::Wire::zero_padding(value);
9702 }
9703 }
9704
9705 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig16Request
9706 where
9707 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9708 {
9709 fn decode(
9710 slot_: ::fidl_next::Slot<'_, Self>,
9711 decoder_: &mut ___D,
9712 _: (),
9713 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9714 ::fidl_next::munge! {
9715 let Self {
9716 mut offset,
9717 mut value,
9718
9719 } = slot_;
9720 }
9721
9722 let _field = offset.as_mut();
9723
9724 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9725
9726 let _field = value.as_mut();
9727
9728 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9729
9730 Ok(())
9731 }
9732 }
9733
9734 impl ::fidl_next::IntoNatural for DeviceWriteConfig16Request {
9735 type Natural = crate::natural::DeviceWriteConfig16Request;
9736 }
9737
9738 pub type DeviceWriteConfig16Response = ::fidl_next::wire::Unit;
9740
9741 #[derive(Clone, Debug)]
9743 #[repr(C)]
9744 pub struct DeviceWriteConfig32Request {
9745 pub offset: ::fidl_next::wire::Uint16,
9746
9747 pub value: ::fidl_next::wire::Uint32,
9748 }
9749
9750 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig32Request>(), 8);
9751 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig32Request>(), 4);
9752
9753 static_assertions::const_assert_eq!(
9754 std::mem::offset_of!(DeviceWriteConfig32Request, offset),
9755 0
9756 );
9757
9758 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig32Request, value), 4);
9759
9760 impl ::fidl_next::Constrained for DeviceWriteConfig32Request {
9761 type Constraint = ();
9762
9763 fn validate(
9764 _: ::fidl_next::Slot<'_, Self>,
9765 _: Self::Constraint,
9766 ) -> Result<(), ::fidl_next::ValidationError> {
9767 Ok(())
9768 }
9769 }
9770
9771 unsafe impl ::fidl_next::Wire for DeviceWriteConfig32Request {
9772 type Narrowed<'de> = DeviceWriteConfig32Request;
9773
9774 #[inline]
9775 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9776 ::fidl_next::munge! {
9777 let Self {
9778 offset,
9779 value,
9780
9781 } = &mut *out_;
9782 }
9783
9784 ::fidl_next::Wire::zero_padding(offset);
9785
9786 ::fidl_next::Wire::zero_padding(value);
9787
9788 unsafe {
9789 out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 2);
9790 }
9791 }
9792 }
9793
9794 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig32Request
9795 where
9796 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9797 {
9798 fn decode(
9799 slot_: ::fidl_next::Slot<'_, Self>,
9800 decoder_: &mut ___D,
9801 _: (),
9802 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9803 if slot_.as_bytes()[2..4] != [0u8; 2] {
9804 return Err(::fidl_next::DecodeError::InvalidPadding);
9805 }
9806
9807 ::fidl_next::munge! {
9808 let Self {
9809 mut offset,
9810 mut value,
9811
9812 } = slot_;
9813 }
9814
9815 let _field = offset.as_mut();
9816
9817 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9818
9819 let _field = value.as_mut();
9820
9821 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9822
9823 Ok(())
9824 }
9825 }
9826
9827 impl ::fidl_next::IntoNatural for DeviceWriteConfig32Request {
9828 type Natural = crate::natural::DeviceWriteConfig32Request;
9829 }
9830
9831 pub type DeviceWriteConfig32Response = ::fidl_next::wire::Unit;
9833
9834 #[derive(Clone, Debug)]
9836 #[repr(C)]
9837 pub struct DeviceGetCapabilitiesRequest {
9838 pub id: crate::wire::CapabilityId,
9839 }
9840
9841 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetCapabilitiesRequest>(), 1);
9842 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetCapabilitiesRequest>(), 1);
9843
9844 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetCapabilitiesRequest, id), 0);
9845
9846 impl ::fidl_next::Constrained for DeviceGetCapabilitiesRequest {
9847 type Constraint = ();
9848
9849 fn validate(
9850 _: ::fidl_next::Slot<'_, Self>,
9851 _: Self::Constraint,
9852 ) -> Result<(), ::fidl_next::ValidationError> {
9853 Ok(())
9854 }
9855 }
9856
9857 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesRequest {
9858 type Narrowed<'de> = DeviceGetCapabilitiesRequest;
9859
9860 #[inline]
9861 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9862 ::fidl_next::munge! {
9863 let Self {
9864 id,
9865
9866 } = &mut *out_;
9867 }
9868
9869 ::fidl_next::Wire::zero_padding(id);
9870 }
9871 }
9872
9873 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesRequest
9874 where
9875 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9876 {
9877 fn decode(
9878 slot_: ::fidl_next::Slot<'_, Self>,
9879 decoder_: &mut ___D,
9880 _: (),
9881 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9882 ::fidl_next::munge! {
9883 let Self {
9884 mut id,
9885
9886 } = slot_;
9887 }
9888
9889 let _field = id.as_mut();
9890
9891 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9892
9893 Ok(())
9894 }
9895 }
9896
9897 impl ::fidl_next::IntoNatural for DeviceGetCapabilitiesRequest {
9898 type Natural = crate::natural::DeviceGetCapabilitiesRequest;
9899 }
9900
9901 #[derive(Debug)]
9903 #[repr(C)]
9904 pub struct DeviceGetCapabilitiesResponse<'de> {
9905 pub offsets: ::fidl_next::wire::Vector<'de, u8>,
9906 }
9907
9908 static_assertions::const_assert_eq!(
9909 std::mem::size_of::<DeviceGetCapabilitiesResponse<'_>>(),
9910 16
9911 );
9912 static_assertions::const_assert_eq!(
9913 std::mem::align_of::<DeviceGetCapabilitiesResponse<'_>>(),
9914 8
9915 );
9916
9917 static_assertions::const_assert_eq!(
9918 std::mem::offset_of!(DeviceGetCapabilitiesResponse<'_>, offsets),
9919 0
9920 );
9921
9922 impl ::fidl_next::Constrained for DeviceGetCapabilitiesResponse<'_> {
9923 type Constraint = ();
9924
9925 fn validate(
9926 _: ::fidl_next::Slot<'_, Self>,
9927 _: Self::Constraint,
9928 ) -> Result<(), ::fidl_next::ValidationError> {
9929 Ok(())
9930 }
9931 }
9932
9933 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesResponse<'static> {
9934 type Narrowed<'de> = DeviceGetCapabilitiesResponse<'de>;
9935
9936 #[inline]
9937 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9938 ::fidl_next::munge! {
9939 let Self {
9940 offsets,
9941
9942 } = &mut *out_;
9943 }
9944
9945 ::fidl_next::Wire::zero_padding(offsets);
9946 }
9947 }
9948
9949 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesResponse<'de>
9950 where
9951 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9952 ___D: ::fidl_next::Decoder<'de>,
9953 {
9954 fn decode(
9955 slot_: ::fidl_next::Slot<'_, Self>,
9956 decoder_: &mut ___D,
9957 _: (),
9958 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9959 ::fidl_next::munge! {
9960 let Self {
9961 mut offsets,
9962
9963 } = slot_;
9964 }
9965
9966 let _field = offsets.as_mut();
9967 ::fidl_next::Constrained::validate(_field, (32, ()))?;
9968 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
9969
9970 let offsets = unsafe { offsets.deref_unchecked() };
9971
9972 if offsets.len() > 32 {
9973 return Err(::fidl_next::DecodeError::VectorTooLong {
9974 size: offsets.len() as u64,
9975 limit: 32,
9976 });
9977 }
9978
9979 Ok(())
9980 }
9981 }
9982
9983 impl<'de> ::fidl_next::IntoNatural for DeviceGetCapabilitiesResponse<'de> {
9984 type Natural = crate::natural::DeviceGetCapabilitiesResponse;
9985 }
9986
9987 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9989 #[repr(transparent)]
9990 pub struct ExtendedCapabilityId {
9991 pub(crate) value: ::fidl_next::wire::Uint16,
9992 }
9993
9994 impl ::fidl_next::Constrained for ExtendedCapabilityId {
9995 type Constraint = ();
9996
9997 fn validate(
9998 _: ::fidl_next::Slot<'_, Self>,
9999 _: Self::Constraint,
10000 ) -> Result<(), ::fidl_next::ValidationError> {
10001 Ok(())
10002 }
10003 }
10004
10005 unsafe impl ::fidl_next::Wire for ExtendedCapabilityId {
10006 type Narrowed<'de> = Self;
10007
10008 #[inline]
10009 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10010 }
10012 }
10013
10014 impl ExtendedCapabilityId {
10015 pub const NULL: ExtendedCapabilityId =
10016 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(0) };
10017
10018 pub const ADVANCED_ERROR_REPORTING: ExtendedCapabilityId =
10019 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(1) };
10020
10021 pub const VIRTUAL_CHANNEL_NO_MFVC: ExtendedCapabilityId =
10022 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(2) };
10023
10024 pub const DEVICE_SERIAL_NUMBER: ExtendedCapabilityId =
10025 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(3) };
10026
10027 pub const POWER_BUDGETING: ExtendedCapabilityId =
10028 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(4) };
10029
10030 pub const ROOT_COMPLEX_LINK_DECLARATION: ExtendedCapabilityId =
10031 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(5) };
10032
10033 pub const ROOT_COMPLEX_INTERNAL_LINK_CONTROL: ExtendedCapabilityId =
10034 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(6) };
10035
10036 pub const ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION: ExtendedCapabilityId =
10037 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(7) };
10038
10039 pub const MULTI_FUNCTION_VIRTUAL_CHANNEL: ExtendedCapabilityId =
10040 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(8) };
10041
10042 pub const VIRTUAL_CHANNEL: ExtendedCapabilityId =
10043 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(9) };
10044
10045 pub const RCRB: ExtendedCapabilityId =
10046 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(10) };
10047
10048 pub const VENDOR: ExtendedCapabilityId =
10049 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(11) };
10050
10051 pub const CAC: ExtendedCapabilityId =
10052 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(12) };
10053
10054 pub const ACS: ExtendedCapabilityId =
10055 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(13) };
10056
10057 pub const ARI: ExtendedCapabilityId =
10058 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(14) };
10059
10060 pub const ATS: ExtendedCapabilityId =
10061 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(15) };
10062
10063 pub const SR_IOV: ExtendedCapabilityId =
10064 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(16) };
10065
10066 pub const MR_IOV: ExtendedCapabilityId =
10067 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(17) };
10068
10069 pub const MULTICAST: ExtendedCapabilityId =
10070 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(18) };
10071
10072 pub const PRI: ExtendedCapabilityId =
10073 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(19) };
10074
10075 pub const ENHANCED_ALLOCATION: ExtendedCapabilityId =
10076 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(20) };
10077
10078 pub const RESIZABLE_BAR: ExtendedCapabilityId =
10079 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(21) };
10080
10081 pub const DYNAMIC_POWER_ALLOCATION: ExtendedCapabilityId =
10082 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(22) };
10083
10084 pub const TPH: ExtendedCapabilityId =
10085 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(23) };
10086
10087 pub const LATENCY_TOLERANCE_REPORTING: ExtendedCapabilityId =
10088 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(24) };
10089
10090 pub const SECONDARY_PCI_EXPRESS: ExtendedCapabilityId =
10091 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(25) };
10092
10093 pub const PMUX: ExtendedCapabilityId =
10094 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(26) };
10095
10096 pub const PASID: ExtendedCapabilityId =
10097 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(27) };
10098
10099 pub const LNR: ExtendedCapabilityId =
10100 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(28) };
10101
10102 pub const DPC: ExtendedCapabilityId =
10103 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(29) };
10104
10105 pub const L1_PM_SUBSTATES: ExtendedCapabilityId =
10106 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(30) };
10107
10108 pub const PRECISION_TIME_MEASUREMENT: ExtendedCapabilityId =
10109 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(31) };
10110
10111 pub const MPCIE: ExtendedCapabilityId =
10112 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(32) };
10113
10114 pub const FRS_QUEUEING: ExtendedCapabilityId =
10115 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(33) };
10116
10117 pub const READINESS_TIME_REPORTING: ExtendedCapabilityId =
10118 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(34) };
10119
10120 pub const DESIGNATED_VENDOR: ExtendedCapabilityId =
10121 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(35) };
10122
10123 pub const VF_RESIZABLE_BAR: ExtendedCapabilityId =
10124 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(36) };
10125
10126 pub const DATA_LINK_FEATURE: ExtendedCapabilityId =
10127 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(37) };
10128
10129 pub const PHYSICAL_LAYER_16: ExtendedCapabilityId =
10130 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(38) };
10131
10132 pub const LANE_MARGINING_AT_RECEIVER: ExtendedCapabilityId =
10133 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(39) };
10134
10135 pub const HIERARCHY_ID: ExtendedCapabilityId =
10136 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(40) };
10137
10138 pub const NATIVE_PCIE_ENCLOSURE: ExtendedCapabilityId =
10139 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(41) };
10140
10141 pub const PHYSICAL_LAYER_32: ExtendedCapabilityId =
10142 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(42) };
10143
10144 pub const ALTERNATE_PROTOCOL: ExtendedCapabilityId =
10145 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(43) };
10146
10147 pub const SYSTEM_FIRMWARE_INTERMEDIARY: ExtendedCapabilityId =
10148 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(44) };
10149 }
10150
10151 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapabilityId
10152 where
10153 ___D: ?Sized,
10154 {
10155 fn decode(
10156 slot: ::fidl_next::Slot<'_, Self>,
10157 _: &mut ___D,
10158 _: (),
10159 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10160 Ok(())
10161 }
10162 }
10163
10164 impl ::core::convert::From<crate::natural::ExtendedCapabilityId> for ExtendedCapabilityId {
10165 fn from(natural: crate::natural::ExtendedCapabilityId) -> Self {
10166 match natural {
10167
10168 crate::natural::ExtendedCapabilityId::Null => ExtendedCapabilityId::NULL,
10169
10170 crate::natural::ExtendedCapabilityId::AdvancedErrorReporting => ExtendedCapabilityId::ADVANCED_ERROR_REPORTING,
10171
10172 crate::natural::ExtendedCapabilityId::VirtualChannelNoMfvc => ExtendedCapabilityId::VIRTUAL_CHANNEL_NO_MFVC,
10173
10174 crate::natural::ExtendedCapabilityId::DeviceSerialNumber => ExtendedCapabilityId::DEVICE_SERIAL_NUMBER,
10175
10176 crate::natural::ExtendedCapabilityId::PowerBudgeting => ExtendedCapabilityId::POWER_BUDGETING,
10177
10178 crate::natural::ExtendedCapabilityId::RootComplexLinkDeclaration => ExtendedCapabilityId::ROOT_COMPLEX_LINK_DECLARATION,
10179
10180 crate::natural::ExtendedCapabilityId::RootComplexInternalLinkControl => ExtendedCapabilityId::ROOT_COMPLEX_INTERNAL_LINK_CONTROL,
10181
10182 crate::natural::ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => ExtendedCapabilityId::ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION,
10183
10184 crate::natural::ExtendedCapabilityId::MultiFunctionVirtualChannel => ExtendedCapabilityId::MULTI_FUNCTION_VIRTUAL_CHANNEL,
10185
10186 crate::natural::ExtendedCapabilityId::VirtualChannel => ExtendedCapabilityId::VIRTUAL_CHANNEL,
10187
10188 crate::natural::ExtendedCapabilityId::Rcrb => ExtendedCapabilityId::RCRB,
10189
10190 crate::natural::ExtendedCapabilityId::Vendor => ExtendedCapabilityId::VENDOR,
10191
10192 crate::natural::ExtendedCapabilityId::Cac => ExtendedCapabilityId::CAC,
10193
10194 crate::natural::ExtendedCapabilityId::Acs => ExtendedCapabilityId::ACS,
10195
10196 crate::natural::ExtendedCapabilityId::Ari => ExtendedCapabilityId::ARI,
10197
10198 crate::natural::ExtendedCapabilityId::Ats => ExtendedCapabilityId::ATS,
10199
10200 crate::natural::ExtendedCapabilityId::SrIov => ExtendedCapabilityId::SR_IOV,
10201
10202 crate::natural::ExtendedCapabilityId::MrIov => ExtendedCapabilityId::MR_IOV,
10203
10204 crate::natural::ExtendedCapabilityId::Multicast => ExtendedCapabilityId::MULTICAST,
10205
10206 crate::natural::ExtendedCapabilityId::Pri => ExtendedCapabilityId::PRI,
10207
10208 crate::natural::ExtendedCapabilityId::EnhancedAllocation => ExtendedCapabilityId::ENHANCED_ALLOCATION,
10209
10210 crate::natural::ExtendedCapabilityId::ResizableBar => ExtendedCapabilityId::RESIZABLE_BAR,
10211
10212 crate::natural::ExtendedCapabilityId::DynamicPowerAllocation => ExtendedCapabilityId::DYNAMIC_POWER_ALLOCATION,
10213
10214 crate::natural::ExtendedCapabilityId::Tph => ExtendedCapabilityId::TPH,
10215
10216 crate::natural::ExtendedCapabilityId::LatencyToleranceReporting => ExtendedCapabilityId::LATENCY_TOLERANCE_REPORTING,
10217
10218 crate::natural::ExtendedCapabilityId::SecondaryPciExpress => ExtendedCapabilityId::SECONDARY_PCI_EXPRESS,
10219
10220 crate::natural::ExtendedCapabilityId::Pmux => ExtendedCapabilityId::PMUX,
10221
10222 crate::natural::ExtendedCapabilityId::Pasid => ExtendedCapabilityId::PASID,
10223
10224 crate::natural::ExtendedCapabilityId::Lnr => ExtendedCapabilityId::LNR,
10225
10226 crate::natural::ExtendedCapabilityId::Dpc => ExtendedCapabilityId::DPC,
10227
10228 crate::natural::ExtendedCapabilityId::L1PmSubstates => ExtendedCapabilityId::L1_PM_SUBSTATES,
10229
10230 crate::natural::ExtendedCapabilityId::PrecisionTimeMeasurement => ExtendedCapabilityId::PRECISION_TIME_MEASUREMENT,
10231
10232 crate::natural::ExtendedCapabilityId::Mpcie => ExtendedCapabilityId::MPCIE,
10233
10234 crate::natural::ExtendedCapabilityId::FrsQueueing => ExtendedCapabilityId::FRS_QUEUEING,
10235
10236 crate::natural::ExtendedCapabilityId::ReadinessTimeReporting => ExtendedCapabilityId::READINESS_TIME_REPORTING,
10237
10238 crate::natural::ExtendedCapabilityId::DesignatedVendor => ExtendedCapabilityId::DESIGNATED_VENDOR,
10239
10240 crate::natural::ExtendedCapabilityId::VfResizableBar => ExtendedCapabilityId::VF_RESIZABLE_BAR,
10241
10242 crate::natural::ExtendedCapabilityId::DataLinkFeature => ExtendedCapabilityId::DATA_LINK_FEATURE,
10243
10244 crate::natural::ExtendedCapabilityId::PhysicalLayer16 => ExtendedCapabilityId::PHYSICAL_LAYER_16,
10245
10246 crate::natural::ExtendedCapabilityId::LaneMarginingAtReceiver => ExtendedCapabilityId::LANE_MARGINING_AT_RECEIVER,
10247
10248 crate::natural::ExtendedCapabilityId::HierarchyId => ExtendedCapabilityId::HIERARCHY_ID,
10249
10250 crate::natural::ExtendedCapabilityId::NativePcieEnclosure => ExtendedCapabilityId::NATIVE_PCIE_ENCLOSURE,
10251
10252 crate::natural::ExtendedCapabilityId::PhysicalLayer32 => ExtendedCapabilityId::PHYSICAL_LAYER_32,
10253
10254 crate::natural::ExtendedCapabilityId::AlternateProtocol => ExtendedCapabilityId::ALTERNATE_PROTOCOL,
10255
10256 crate::natural::ExtendedCapabilityId::SystemFirmwareIntermediary => ExtendedCapabilityId::SYSTEM_FIRMWARE_INTERMEDIARY,
10257
10258
10259 crate::natural::ExtendedCapabilityId::UnknownOrdinal_(value) => ExtendedCapabilityId {
10260 value: ::fidl_next::wire::Uint16::from(value),
10261 }
10262
10263 }
10264 }
10265 }
10266
10267 impl ::fidl_next::IntoNatural for ExtendedCapabilityId {
10268 type Natural = crate::natural::ExtendedCapabilityId;
10269 }
10270
10271 #[derive(Clone, Debug)]
10273 #[repr(C)]
10274 pub struct DeviceGetExtendedCapabilitiesRequest {
10275 pub id: crate::wire::ExtendedCapabilityId,
10276 }
10277
10278 static_assertions::const_assert_eq!(
10279 std::mem::size_of::<DeviceGetExtendedCapabilitiesRequest>(),
10280 2
10281 );
10282 static_assertions::const_assert_eq!(
10283 std::mem::align_of::<DeviceGetExtendedCapabilitiesRequest>(),
10284 2
10285 );
10286
10287 static_assertions::const_assert_eq!(
10288 std::mem::offset_of!(DeviceGetExtendedCapabilitiesRequest, id),
10289 0
10290 );
10291
10292 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesRequest {
10293 type Constraint = ();
10294
10295 fn validate(
10296 _: ::fidl_next::Slot<'_, Self>,
10297 _: Self::Constraint,
10298 ) -> Result<(), ::fidl_next::ValidationError> {
10299 Ok(())
10300 }
10301 }
10302
10303 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesRequest {
10304 type Narrowed<'de> = DeviceGetExtendedCapabilitiesRequest;
10305
10306 #[inline]
10307 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10308 ::fidl_next::munge! {
10309 let Self {
10310 id,
10311
10312 } = &mut *out_;
10313 }
10314
10315 ::fidl_next::Wire::zero_padding(id);
10316 }
10317 }
10318
10319 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesRequest
10320 where
10321 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10322 {
10323 fn decode(
10324 slot_: ::fidl_next::Slot<'_, Self>,
10325 decoder_: &mut ___D,
10326 _: (),
10327 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10328 ::fidl_next::munge! {
10329 let Self {
10330 mut id,
10331
10332 } = slot_;
10333 }
10334
10335 let _field = id.as_mut();
10336
10337 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10338
10339 Ok(())
10340 }
10341 }
10342
10343 impl ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesRequest {
10344 type Natural = crate::natural::DeviceGetExtendedCapabilitiesRequest;
10345 }
10346
10347 #[derive(Debug)]
10349 #[repr(C)]
10350 pub struct DeviceGetExtendedCapabilitiesResponse<'de> {
10351 pub offsets: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
10352 }
10353
10354 static_assertions::const_assert_eq!(
10355 std::mem::size_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10356 16
10357 );
10358 static_assertions::const_assert_eq!(
10359 std::mem::align_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10360 8
10361 );
10362
10363 static_assertions::const_assert_eq!(
10364 std::mem::offset_of!(DeviceGetExtendedCapabilitiesResponse<'_>, offsets),
10365 0
10366 );
10367
10368 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesResponse<'_> {
10369 type Constraint = ();
10370
10371 fn validate(
10372 _: ::fidl_next::Slot<'_, Self>,
10373 _: Self::Constraint,
10374 ) -> Result<(), ::fidl_next::ValidationError> {
10375 Ok(())
10376 }
10377 }
10378
10379 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesResponse<'static> {
10380 type Narrowed<'de> = DeviceGetExtendedCapabilitiesResponse<'de>;
10381
10382 #[inline]
10383 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10384 ::fidl_next::munge! {
10385 let Self {
10386 offsets,
10387
10388 } = &mut *out_;
10389 }
10390
10391 ::fidl_next::Wire::zero_padding(offsets);
10392 }
10393 }
10394
10395 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesResponse<'de>
10396 where
10397 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10398 ___D: ::fidl_next::Decoder<'de>,
10399 {
10400 fn decode(
10401 slot_: ::fidl_next::Slot<'_, Self>,
10402 decoder_: &mut ___D,
10403 _: (),
10404 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10405 ::fidl_next::munge! {
10406 let Self {
10407 mut offsets,
10408
10409 } = slot_;
10410 }
10411
10412 let _field = offsets.as_mut();
10413 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10414 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
10415
10416 let offsets = unsafe { offsets.deref_unchecked() };
10417
10418 if offsets.len() > 32 {
10419 return Err(::fidl_next::DecodeError::VectorTooLong {
10420 size: offsets.len() as u64,
10421 limit: 32,
10422 });
10423 }
10424
10425 Ok(())
10426 }
10427 }
10428
10429 impl<'de> ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesResponse<'de> {
10430 type Natural = crate::natural::DeviceGetExtendedCapabilitiesResponse;
10431 }
10432
10433 #[derive(Clone, Debug)]
10435 #[repr(C)]
10436 pub struct DeviceGetBtiRequest {
10437 pub index: ::fidl_next::wire::Uint32,
10438 }
10439
10440 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBtiRequest>(), 4);
10441 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBtiRequest>(), 4);
10442
10443 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBtiRequest, index), 0);
10444
10445 impl ::fidl_next::Constrained for DeviceGetBtiRequest {
10446 type Constraint = ();
10447
10448 fn validate(
10449 _: ::fidl_next::Slot<'_, Self>,
10450 _: Self::Constraint,
10451 ) -> Result<(), ::fidl_next::ValidationError> {
10452 Ok(())
10453 }
10454 }
10455
10456 unsafe impl ::fidl_next::Wire for DeviceGetBtiRequest {
10457 type Narrowed<'de> = DeviceGetBtiRequest;
10458
10459 #[inline]
10460 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10461 ::fidl_next::munge! {
10462 let Self {
10463 index,
10464
10465 } = &mut *out_;
10466 }
10467
10468 ::fidl_next::Wire::zero_padding(index);
10469 }
10470 }
10471
10472 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBtiRequest
10473 where
10474 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10475 {
10476 fn decode(
10477 slot_: ::fidl_next::Slot<'_, Self>,
10478 decoder_: &mut ___D,
10479 _: (),
10480 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10481 ::fidl_next::munge! {
10482 let Self {
10483 mut index,
10484
10485 } = slot_;
10486 }
10487
10488 let _field = index.as_mut();
10489
10490 ::fidl_next::Decode::decode(index.as_mut(), decoder_, ())?;
10491
10492 Ok(())
10493 }
10494 }
10495
10496 impl ::fidl_next::IntoNatural for DeviceGetBtiRequest {
10497 type Natural = crate::natural::DeviceGetBtiRequest;
10498 }
10499
10500 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10502 #[repr(transparent)]
10503 pub struct InterruptMode {
10504 pub(crate) value: u8,
10505 }
10506
10507 impl ::fidl_next::Constrained for InterruptMode {
10508 type Constraint = ();
10509
10510 fn validate(
10511 _: ::fidl_next::Slot<'_, Self>,
10512 _: Self::Constraint,
10513 ) -> Result<(), ::fidl_next::ValidationError> {
10514 Ok(())
10515 }
10516 }
10517
10518 unsafe impl ::fidl_next::Wire for InterruptMode {
10519 type Narrowed<'de> = Self;
10520
10521 #[inline]
10522 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10523 }
10525 }
10526
10527 impl InterruptMode {
10528 pub const DISABLED: InterruptMode = InterruptMode { value: 0 };
10529
10530 pub const LEGACY: InterruptMode = InterruptMode { value: 1 };
10531
10532 pub const LEGACY_NOACK: InterruptMode = InterruptMode { value: 2 };
10533
10534 pub const MSI: InterruptMode = InterruptMode { value: 3 };
10535
10536 pub const MSI_X: InterruptMode = InterruptMode { value: 4 };
10537 }
10538
10539 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptMode
10540 where
10541 ___D: ?Sized,
10542 {
10543 fn decode(
10544 slot: ::fidl_next::Slot<'_, Self>,
10545 _: &mut ___D,
10546 _: (),
10547 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10548 Ok(())
10549 }
10550 }
10551
10552 impl ::core::convert::From<crate::natural::InterruptMode> for InterruptMode {
10553 fn from(natural: crate::natural::InterruptMode) -> Self {
10554 match natural {
10555 crate::natural::InterruptMode::Disabled => InterruptMode::DISABLED,
10556
10557 crate::natural::InterruptMode::Legacy => InterruptMode::LEGACY,
10558
10559 crate::natural::InterruptMode::LegacyNoack => InterruptMode::LEGACY_NOACK,
10560
10561 crate::natural::InterruptMode::Msi => InterruptMode::MSI,
10562
10563 crate::natural::InterruptMode::MsiX => InterruptMode::MSI_X,
10564
10565 crate::natural::InterruptMode::UnknownOrdinal_(value) => {
10566 InterruptMode { value: u8::from(value) }
10567 }
10568 }
10569 }
10570 }
10571
10572 impl ::fidl_next::IntoNatural for InterruptMode {
10573 type Natural = crate::natural::InterruptMode;
10574 }
10575
10576 #[derive(Clone, Debug)]
10578 #[repr(C)]
10579 pub struct DeviceSetInterruptModeRequest {
10580 pub mode: crate::wire::InterruptMode,
10581
10582 pub requested_irq_count: ::fidl_next::wire::Uint32,
10583 }
10584
10585 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetInterruptModeRequest>(), 8);
10586 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetInterruptModeRequest>(), 4);
10587
10588 static_assertions::const_assert_eq!(
10589 std::mem::offset_of!(DeviceSetInterruptModeRequest, mode),
10590 0
10591 );
10592
10593 static_assertions::const_assert_eq!(
10594 std::mem::offset_of!(DeviceSetInterruptModeRequest, requested_irq_count),
10595 4
10596 );
10597
10598 impl ::fidl_next::Constrained for DeviceSetInterruptModeRequest {
10599 type Constraint = ();
10600
10601 fn validate(
10602 _: ::fidl_next::Slot<'_, Self>,
10603 _: Self::Constraint,
10604 ) -> Result<(), ::fidl_next::ValidationError> {
10605 Ok(())
10606 }
10607 }
10608
10609 unsafe impl ::fidl_next::Wire for DeviceSetInterruptModeRequest {
10610 type Narrowed<'de> = DeviceSetInterruptModeRequest;
10611
10612 #[inline]
10613 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10614 ::fidl_next::munge! {
10615 let Self {
10616 mode,
10617 requested_irq_count,
10618
10619 } = &mut *out_;
10620 }
10621
10622 ::fidl_next::Wire::zero_padding(mode);
10623
10624 ::fidl_next::Wire::zero_padding(requested_irq_count);
10625
10626 unsafe {
10627 out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
10628 }
10629 }
10630 }
10631
10632 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetInterruptModeRequest
10633 where
10634 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10635 {
10636 fn decode(
10637 slot_: ::fidl_next::Slot<'_, Self>,
10638 decoder_: &mut ___D,
10639 _: (),
10640 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10641 if slot_.as_bytes()[1..4] != [0u8; 3] {
10642 return Err(::fidl_next::DecodeError::InvalidPadding);
10643 }
10644
10645 ::fidl_next::munge! {
10646 let Self {
10647 mut mode,
10648 mut requested_irq_count,
10649
10650 } = slot_;
10651 }
10652
10653 let _field = mode.as_mut();
10654
10655 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
10656
10657 let _field = requested_irq_count.as_mut();
10658
10659 ::fidl_next::Decode::decode(requested_irq_count.as_mut(), decoder_, ())?;
10660
10661 Ok(())
10662 }
10663 }
10664
10665 impl ::fidl_next::IntoNatural for DeviceSetInterruptModeRequest {
10666 type Natural = crate::natural::DeviceSetInterruptModeRequest;
10667 }
10668
10669 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10671 #[repr(transparent)]
10672 pub struct HeaderType {
10673 pub(crate) value: u8,
10674 }
10675
10676 impl ::fidl_next::Constrained for HeaderType {
10677 type Constraint = ();
10678
10679 fn validate(
10680 _: ::fidl_next::Slot<'_, Self>,
10681 _: Self::Constraint,
10682 ) -> Result<(), ::fidl_next::ValidationError> {
10683 Ok(())
10684 }
10685 }
10686
10687 unsafe impl ::fidl_next::Wire for HeaderType {
10688 type Narrowed<'de> = Self;
10689
10690 #[inline]
10691 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10692 }
10694 }
10695
10696 impl HeaderType {
10697 pub const STANDARD: HeaderType = HeaderType { value: 0 };
10698
10699 pub const BRIDGE: HeaderType = HeaderType { value: 1 };
10700
10701 pub const CARD_BUS: HeaderType = HeaderType { value: 2 };
10702
10703 pub const MASK: HeaderType = HeaderType { value: 127 };
10704
10705 pub const MULTI_FN: HeaderType = HeaderType { value: 128 };
10706 }
10707
10708 unsafe impl<___D> ::fidl_next::Decode<___D> for HeaderType
10709 where
10710 ___D: ?Sized,
10711 {
10712 fn decode(
10713 slot: ::fidl_next::Slot<'_, Self>,
10714 _: &mut ___D,
10715 _: (),
10716 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10717 Ok(())
10718 }
10719 }
10720
10721 impl ::core::convert::From<crate::natural::HeaderType> for HeaderType {
10722 fn from(natural: crate::natural::HeaderType) -> Self {
10723 match natural {
10724 crate::natural::HeaderType::Standard => HeaderType::STANDARD,
10725
10726 crate::natural::HeaderType::Bridge => HeaderType::BRIDGE,
10727
10728 crate::natural::HeaderType::CardBus => HeaderType::CARD_BUS,
10729
10730 crate::natural::HeaderType::Mask => HeaderType::MASK,
10731
10732 crate::natural::HeaderType::MultiFn => HeaderType::MULTI_FN,
10733
10734 crate::natural::HeaderType::UnknownOrdinal_(value) => {
10735 HeaderType { value: u8::from(value) }
10736 }
10737 }
10738 }
10739 }
10740
10741 impl ::fidl_next::IntoNatural for HeaderType {
10742 type Natural = crate::natural::HeaderType;
10743 }
10744
10745 #[derive(Clone, Copy, Debug)]
10747 #[repr(transparent)]
10748 pub struct Status {
10749 pub(crate) value: ::fidl_next::wire::Uint16,
10750 }
10751
10752 impl ::fidl_next::Constrained for Status {
10753 type Constraint = ();
10754
10755 fn validate(
10756 _: ::fidl_next::Slot<'_, Self>,
10757 _: Self::Constraint,
10758 ) -> Result<(), ::fidl_next::ValidationError> {
10759 Ok(())
10760 }
10761 }
10762
10763 unsafe impl ::fidl_next::Wire for Status {
10764 type Narrowed<'de> = Self;
10765
10766 #[inline]
10767 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10768 }
10770 }
10771
10772 unsafe impl<___D> ::fidl_next::Decode<___D> for Status
10773 where
10774 ___D: ?Sized,
10775 {
10776 fn decode(
10777 slot: ::fidl_next::Slot<'_, Self>,
10778 _: &mut ___D,
10779 _: (),
10780 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10781 Ok(())
10782 }
10783 }
10784
10785 impl ::core::convert::From<crate::natural::Status> for Status {
10786 fn from(natural: crate::natural::Status) -> Self {
10787 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
10788 }
10789 }
10790
10791 impl ::fidl_next::IntoNatural for Status {
10792 type Natural = crate::natural::Status;
10793 }
10794}
10795
10796pub mod wire_optional {}
10797
10798pub mod generic {
10799
10800 pub struct Address<T0, T1, T2> {
10802 pub bus: T0,
10803
10804 pub device: T1,
10805
10806 pub function: T2,
10807 }
10808
10809 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Address, ___E>
10810 for Address<T0, T1, T2>
10811 where
10812 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10813 T0: ::fidl_next::Encode<u8, ___E>,
10814 T1: ::fidl_next::Encode<u8, ___E>,
10815 T2: ::fidl_next::Encode<u8, ___E>,
10816 {
10817 #[inline]
10818 fn encode(
10819 self,
10820 encoder_: &mut ___E,
10821 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
10822 _: (),
10823 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10824 ::fidl_next::munge! {
10825 let crate::wire::Address {
10826 bus,
10827 device,
10828 function,
10829
10830 } = out_;
10831 }
10832
10833 ::fidl_next::Encode::encode(self.bus, encoder_, bus, ())?;
10834
10835 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
10836
10837 ::fidl_next::Encode::encode(self.function, encoder_, function, ())?;
10838
10839 Ok(())
10840 }
10841 }
10842
10843 pub struct BaseAddress<T0, T1, T2, T3, T4, T5> {
10845 pub address: T0,
10846
10847 pub size: T1,
10848
10849 pub is_memory: T2,
10850
10851 pub is_prefetchable: T3,
10852
10853 pub is_64bit: T4,
10854
10855 pub id: T5,
10856 }
10857
10858 unsafe impl<___E, T0, T1, T2, T3, T4, T5> ::fidl_next::Encode<crate::wire::BaseAddress, ___E>
10859 for BaseAddress<T0, T1, T2, T3, T4, T5>
10860 where
10861 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10862 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10863 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10864 T2: ::fidl_next::Encode<bool, ___E>,
10865 T3: ::fidl_next::Encode<bool, ___E>,
10866 T4: ::fidl_next::Encode<bool, ___E>,
10867 T5: ::fidl_next::Encode<u8, ___E>,
10868 {
10869 #[inline]
10870 fn encode(
10871 self,
10872 encoder_: &mut ___E,
10873 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
10874 _: (),
10875 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10876 ::fidl_next::munge! {
10877 let crate::wire::BaseAddress {
10878 address,
10879 size,
10880 is_memory,
10881 is_prefetchable,
10882 is_64bit,
10883 id,
10884
10885 } = out_;
10886 }
10887
10888 ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;
10889
10890 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10891
10892 ::fidl_next::Encode::encode(self.is_memory, encoder_, is_memory, ())?;
10893
10894 ::fidl_next::Encode::encode(self.is_prefetchable, encoder_, is_prefetchable, ())?;
10895
10896 ::fidl_next::Encode::encode(self.is_64bit, encoder_, is_64bit, ())?;
10897
10898 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10899
10900 Ok(())
10901 }
10902 }
10903
10904 pub type UseIntxWorkaroundType = ();
10906
10907 pub struct HostBridgeInfo<T0, T1, T2, T3> {
10909 pub name: T0,
10910
10911 pub start_bus_number: T1,
10912
10913 pub end_bus_number: T2,
10914
10915 pub segment_group: T3,
10916 }
10917
10918 unsafe impl<___E, T0, T1, T2, T3>
10919 ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
10920 for HostBridgeInfo<T0, T1, T2, T3>
10921 where
10922 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10923 ___E: ::fidl_next::Encoder,
10924 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10925 T1: ::fidl_next::Encode<u8, ___E>,
10926 T2: ::fidl_next::Encode<u8, ___E>,
10927 T3: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10928 {
10929 #[inline]
10930 fn encode(
10931 self,
10932 encoder_: &mut ___E,
10933 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
10934 _: (),
10935 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10936 ::fidl_next::munge! {
10937 let crate::wire::HostBridgeInfo {
10938 name,
10939 start_bus_number,
10940 end_bus_number,
10941 segment_group,
10942
10943 } = out_;
10944 }
10945
10946 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
10947
10948 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
10949
10950 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
10951
10952 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
10953
10954 Ok(())
10955 }
10956 }
10957
10958 pub struct BusGetHostBridgeInfoResponse<T0> {
10960 pub info: T0,
10961 }
10962
10963 unsafe impl<___E, T0>
10964 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
10965 for BusGetHostBridgeInfoResponse<T0>
10966 where
10967 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10968 ___E: ::fidl_next::Encoder,
10969 T0: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
10970 {
10971 #[inline]
10972 fn encode(
10973 self,
10974 encoder_: &mut ___E,
10975 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
10976 _: (),
10977 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10978 ::fidl_next::munge! {
10979 let crate::wire::BusGetHostBridgeInfoResponse {
10980 info,
10981
10982 } = out_;
10983 }
10984
10985 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
10986
10987 Ok(())
10988 }
10989 }
10990
10991 pub struct Capability<T0, T1> {
10993 pub id: T0,
10994
10995 pub offset: T1,
10996 }
10997
10998 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability<T0, T1>
10999 where
11000 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11001 T0: ::fidl_next::Encode<u8, ___E>,
11002 T1: ::fidl_next::Encode<u8, ___E>,
11003 {
11004 #[inline]
11005 fn encode(
11006 self,
11007 encoder_: &mut ___E,
11008 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
11009 _: (),
11010 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11011 ::fidl_next::munge! {
11012 let crate::wire::Capability {
11013 id,
11014 offset,
11015
11016 } = out_;
11017 }
11018
11019 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11020
11021 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11022
11023 Ok(())
11024 }
11025 }
11026
11027 pub struct ExtendedCapability<T0, T1> {
11029 pub id: T0,
11030
11031 pub offset: T1,
11032 }
11033
11034 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
11035 for ExtendedCapability<T0, T1>
11036 where
11037 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11038 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11039 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11040 {
11041 #[inline]
11042 fn encode(
11043 self,
11044 encoder_: &mut ___E,
11045 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
11046 _: (),
11047 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11048 ::fidl_next::munge! {
11049 let crate::wire::ExtendedCapability {
11050 id,
11051 offset,
11052
11053 } = out_;
11054 }
11055
11056 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11057
11058 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11059
11060 Ok(())
11061 }
11062 }
11063
11064 pub struct PciDevice<T0, T1, T2, T3, T4, T5, T6> {
11066 pub base_addresses: T0,
11067
11068 pub capabilities: T1,
11069
11070 pub ext_capabilities: T2,
11071
11072 pub config: T3,
11073
11074 pub bus_id: T4,
11075
11076 pub device_id: T5,
11077
11078 pub function_id: T6,
11079 }
11080
11081 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
11082 ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>
11083 for PciDevice<T0, T1, T2, T3, T4, T5, T6>
11084 where
11085 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11086 ___E: ::fidl_next::Encoder,
11087 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::BaseAddress>, ___E>,
11088 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::Capability>, ___E>,
11089 T2: ::fidl_next::Encode<
11090 ::fidl_next::wire::Vector<'static, crate::wire::ExtendedCapability>,
11091 ___E,
11092 >,
11093 T3: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11094 T4: ::fidl_next::Encode<u8, ___E>,
11095 T5: ::fidl_next::Encode<u8, ___E>,
11096 T6: ::fidl_next::Encode<u8, ___E>,
11097 {
11098 #[inline]
11099 fn encode(
11100 self,
11101 encoder_: &mut ___E,
11102 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
11103 _: (),
11104 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11105 ::fidl_next::munge! {
11106 let crate::wire::PciDevice {
11107 base_addresses,
11108 capabilities,
11109 ext_capabilities,
11110 config,
11111 bus_id,
11112 device_id,
11113 function_id,
11114
11115 } = out_;
11116 }
11117
11118 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
11119
11120 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
11121
11122 ::fidl_next::Encode::encode(
11123 self.ext_capabilities,
11124 encoder_,
11125 ext_capabilities,
11126 (32, ()),
11127 )?;
11128
11129 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
11130
11131 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11132
11133 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11134
11135 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
11136
11137 Ok(())
11138 }
11139 }
11140
11141 pub struct BusGetDevicesResponse<T0> {
11143 pub devices: T0,
11144 }
11145
11146 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
11147 for BusGetDevicesResponse<T0>
11148 where
11149 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11150 ___E: ::fidl_next::Encoder,
11151 T0: ::fidl_next::Encode<
11152 ::fidl_next::wire::Vector<'static, crate::wire::PciDevice<'static>>,
11153 ___E,
11154 >,
11155 {
11156 #[inline]
11157 fn encode(
11158 self,
11159 encoder_: &mut ___E,
11160 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
11161 _: (),
11162 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11163 ::fidl_next::munge! {
11164 let crate::wire::BusGetDevicesResponse {
11165 devices,
11166
11167 } = out_;
11168 }
11169
11170 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
11171
11172 Ok(())
11173 }
11174 }
11175
11176 pub struct BusReadBarRequest<T0, T1, T2, T3> {
11178 pub device: T0,
11179
11180 pub bar_id: T1,
11181
11182 pub offset: T2,
11183
11184 pub size: T3,
11185 }
11186
11187 unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>
11188 for BusReadBarRequest<T0, T1, T2, T3>
11189 where
11190 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11191 T0: ::fidl_next::Encode<crate::wire::Address, ___E>,
11192 T1: ::fidl_next::Encode<u8, ___E>,
11193 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11194 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11195 {
11196 #[inline]
11197 fn encode(
11198 self,
11199 encoder_: &mut ___E,
11200 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
11201 _: (),
11202 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11203 ::fidl_next::munge! {
11204 let crate::wire::BusReadBarRequest {
11205 device,
11206 bar_id,
11207 offset,
11208 size,
11209
11210 } = out_;
11211 }
11212
11213 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
11214
11215 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11216
11217 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11218
11219 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
11220
11221 Ok(())
11222 }
11223 }
11224
11225 pub struct BusReadBarResponse<T0> {
11227 pub buffer: T0,
11228 }
11229
11230 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
11231 for BusReadBarResponse<T0>
11232 where
11233 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11234 ___E: ::fidl_next::Encoder,
11235 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11236 {
11237 #[inline]
11238 fn encode(
11239 self,
11240 encoder_: &mut ___E,
11241 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
11242 _: (),
11243 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11244 ::fidl_next::munge! {
11245 let crate::wire::BusReadBarResponse {
11246 buffer,
11247
11248 } = out_;
11249 }
11250
11251 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
11252
11253 Ok(())
11254 }
11255 }
11256
11257 pub type Padding = ();
11259
11260 pub struct DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
11262 pub vendor_id: T0,
11263
11264 pub device_id: T1,
11265
11266 pub base_class: T2,
11267
11268 pub sub_class: T3,
11269
11270 pub program_interface: T4,
11271
11272 pub revision_id: T5,
11273
11274 pub bus_id: T6,
11275
11276 pub dev_id: T7,
11277
11278 pub func_id: T8,
11279
11280 pub padding: T9,
11281 }
11282
11283 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11284 ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>
11285 for DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11286 where
11287 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11288 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11289 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11290 T2: ::fidl_next::Encode<u8, ___E>,
11291 T3: ::fidl_next::Encode<u8, ___E>,
11292 T4: ::fidl_next::Encode<u8, ___E>,
11293 T5: ::fidl_next::Encode<u8, ___E>,
11294 T6: ::fidl_next::Encode<u8, ___E>,
11295 T7: ::fidl_next::Encode<u8, ___E>,
11296 T8: ::fidl_next::Encode<u8, ___E>,
11297 T9: ::fidl_next::Encode<crate::wire::Padding, ___E>,
11298 {
11299 #[inline]
11300 fn encode(
11301 self,
11302 encoder_: &mut ___E,
11303 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
11304 _: (),
11305 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11306 ::fidl_next::munge! {
11307 let crate::wire::DeviceInfo {
11308 vendor_id,
11309 device_id,
11310 base_class,
11311 sub_class,
11312 program_interface,
11313 revision_id,
11314 bus_id,
11315 dev_id,
11316 func_id,
11317 padding,
11318
11319 } = out_;
11320 }
11321
11322 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
11323
11324 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11325
11326 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
11327
11328 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
11329
11330 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
11331
11332 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
11333
11334 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11335
11336 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
11337
11338 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
11339
11340 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
11341
11342 Ok(())
11343 }
11344 }
11345
11346 pub struct DeviceGetDeviceInfoResponse<T0> {
11348 pub info: T0,
11349 }
11350
11351 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
11352 for DeviceGetDeviceInfoResponse<T0>
11353 where
11354 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11355 T0: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
11356 {
11357 #[inline]
11358 fn encode(
11359 self,
11360 encoder_: &mut ___E,
11361 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
11362 _: (),
11363 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11364 ::fidl_next::munge! {
11365 let crate::wire::DeviceGetDeviceInfoResponse {
11366 info,
11367
11368 } = out_;
11369 }
11370
11371 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
11372
11373 Ok(())
11374 }
11375 }
11376
11377 pub struct DeviceGetBarRequest<T0> {
11379 pub bar_id: T0,
11380 }
11381
11382 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
11383 for DeviceGetBarRequest<T0>
11384 where
11385 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11386 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11387 {
11388 #[inline]
11389 fn encode(
11390 self,
11391 encoder_: &mut ___E,
11392 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
11393 _: (),
11394 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11395 ::fidl_next::munge! {
11396 let crate::wire::DeviceGetBarRequest {
11397 bar_id,
11398
11399 } = out_;
11400 }
11401
11402 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11403
11404 Ok(())
11405 }
11406 }
11407
11408 pub struct DeviceSetBusMasteringRequest<T0> {
11410 pub enabled: T0,
11411 }
11412
11413 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
11414 for DeviceSetBusMasteringRequest<T0>
11415 where
11416 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11417 T0: ::fidl_next::Encode<bool, ___E>,
11418 {
11419 #[inline]
11420 fn encode(
11421 self,
11422 encoder_: &mut ___E,
11423 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
11424 _: (),
11425 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11426 ::fidl_next::munge! {
11427 let crate::wire::DeviceSetBusMasteringRequest {
11428 enabled,
11429
11430 } = out_;
11431 }
11432
11433 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
11434
11435 Ok(())
11436 }
11437 }
11438
11439 pub type DeviceSetBusMasteringResponse = ();
11441
11442 pub type DeviceResetDeviceResponse = ();
11444
11445 pub type DeviceAckInterruptResponse = ();
11447
11448 pub struct DeviceMapInterruptRequest<T0> {
11450 pub which_irq: T0,
11451 }
11452
11453 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
11454 for DeviceMapInterruptRequest<T0>
11455 where
11456 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11457 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11458 {
11459 #[inline]
11460 fn encode(
11461 self,
11462 encoder_: &mut ___E,
11463 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
11464 _: (),
11465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11466 ::fidl_next::munge! {
11467 let crate::wire::DeviceMapInterruptRequest {
11468 which_irq,
11469
11470 } = out_;
11471 }
11472
11473 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
11474
11475 Ok(())
11476 }
11477 }
11478
11479 pub struct InterruptModes<T0, T1, T2> {
11481 pub has_legacy: T0,
11482
11483 pub msi_count: T1,
11484
11485 pub msix_count: T2,
11486 }
11487
11488 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::InterruptModes, ___E>
11489 for InterruptModes<T0, T1, T2>
11490 where
11491 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11492 T0: ::fidl_next::Encode<bool, ___E>,
11493 T1: ::fidl_next::Encode<u8, ___E>,
11494 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11495 {
11496 #[inline]
11497 fn encode(
11498 self,
11499 encoder_: &mut ___E,
11500 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
11501 _: (),
11502 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11503 ::fidl_next::munge! {
11504 let crate::wire::InterruptModes {
11505 has_legacy,
11506 msi_count,
11507 msix_count,
11508
11509 } = out_;
11510 }
11511
11512 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
11513
11514 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
11515
11516 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
11517
11518 Ok(())
11519 }
11520 }
11521
11522 pub struct DeviceGetInterruptModesResponse<T0> {
11524 pub modes: T0,
11525 }
11526
11527 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
11528 for DeviceGetInterruptModesResponse<T0>
11529 where
11530 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11531 T0: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
11532 {
11533 #[inline]
11534 fn encode(
11535 self,
11536 encoder_: &mut ___E,
11537 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
11538 _: (),
11539 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11540 ::fidl_next::munge! {
11541 let crate::wire::DeviceGetInterruptModesResponse {
11542 modes,
11543
11544 } = out_;
11545 }
11546
11547 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
11548
11549 Ok(())
11550 }
11551 }
11552
11553 pub type DeviceSetInterruptModeResponse = ();
11555
11556 pub struct DeviceReadConfig8Request<T0> {
11558 pub offset: T0,
11559 }
11560
11561 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
11562 for DeviceReadConfig8Request<T0>
11563 where
11564 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11565 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11566 {
11567 #[inline]
11568 fn encode(
11569 self,
11570 encoder_: &mut ___E,
11571 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
11572 _: (),
11573 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11574 ::fidl_next::munge! {
11575 let crate::wire::DeviceReadConfig8Request {
11576 offset,
11577
11578 } = out_;
11579 }
11580
11581 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11582
11583 Ok(())
11584 }
11585 }
11586
11587 pub struct DeviceReadConfig8Response<T0> {
11589 pub value: T0,
11590 }
11591
11592 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
11593 for DeviceReadConfig8Response<T0>
11594 where
11595 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11596 T0: ::fidl_next::Encode<u8, ___E>,
11597 {
11598 #[inline]
11599 fn encode(
11600 self,
11601 encoder_: &mut ___E,
11602 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
11603 _: (),
11604 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11605 ::fidl_next::munge! {
11606 let crate::wire::DeviceReadConfig8Response {
11607 value,
11608
11609 } = out_;
11610 }
11611
11612 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11613
11614 Ok(())
11615 }
11616 }
11617
11618 pub struct DeviceReadConfig16Request<T0> {
11620 pub offset: T0,
11621 }
11622
11623 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
11624 for DeviceReadConfig16Request<T0>
11625 where
11626 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11627 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11628 {
11629 #[inline]
11630 fn encode(
11631 self,
11632 encoder_: &mut ___E,
11633 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
11634 _: (),
11635 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11636 ::fidl_next::munge! {
11637 let crate::wire::DeviceReadConfig16Request {
11638 offset,
11639
11640 } = out_;
11641 }
11642
11643 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11644
11645 Ok(())
11646 }
11647 }
11648
11649 pub struct DeviceReadConfig16Response<T0> {
11651 pub value: T0,
11652 }
11653
11654 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
11655 for DeviceReadConfig16Response<T0>
11656 where
11657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11658 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11659 {
11660 #[inline]
11661 fn encode(
11662 self,
11663 encoder_: &mut ___E,
11664 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
11665 _: (),
11666 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11667 ::fidl_next::munge! {
11668 let crate::wire::DeviceReadConfig16Response {
11669 value,
11670
11671 } = out_;
11672 }
11673
11674 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11675
11676 Ok(())
11677 }
11678 }
11679
11680 pub struct DeviceReadConfig32Request<T0> {
11682 pub offset: T0,
11683 }
11684
11685 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
11686 for DeviceReadConfig32Request<T0>
11687 where
11688 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11689 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11690 {
11691 #[inline]
11692 fn encode(
11693 self,
11694 encoder_: &mut ___E,
11695 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
11696 _: (),
11697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11698 ::fidl_next::munge! {
11699 let crate::wire::DeviceReadConfig32Request {
11700 offset,
11701
11702 } = out_;
11703 }
11704
11705 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11706
11707 Ok(())
11708 }
11709 }
11710
11711 pub struct DeviceReadConfig32Response<T0> {
11713 pub value: T0,
11714 }
11715
11716 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
11717 for DeviceReadConfig32Response<T0>
11718 where
11719 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11720 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11721 {
11722 #[inline]
11723 fn encode(
11724 self,
11725 encoder_: &mut ___E,
11726 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
11727 _: (),
11728 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11729 ::fidl_next::munge! {
11730 let crate::wire::DeviceReadConfig32Response {
11731 value,
11732
11733 } = out_;
11734 }
11735
11736 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11737
11738 Ok(())
11739 }
11740 }
11741
11742 pub struct DeviceWriteConfig8Request<T0, T1> {
11744 pub offset: T0,
11745
11746 pub value: T1,
11747 }
11748
11749 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
11750 for DeviceWriteConfig8Request<T0, T1>
11751 where
11752 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11753 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11754 T1: ::fidl_next::Encode<u8, ___E>,
11755 {
11756 #[inline]
11757 fn encode(
11758 self,
11759 encoder_: &mut ___E,
11760 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
11761 _: (),
11762 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11763 ::fidl_next::munge! {
11764 let crate::wire::DeviceWriteConfig8Request {
11765 offset,
11766 value,
11767
11768 } = out_;
11769 }
11770
11771 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11772
11773 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11774
11775 Ok(())
11776 }
11777 }
11778
11779 pub type DeviceWriteConfig8Response = ();
11781
11782 pub struct DeviceWriteConfig16Request<T0, T1> {
11784 pub offset: T0,
11785
11786 pub value: T1,
11787 }
11788
11789 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
11790 for DeviceWriteConfig16Request<T0, T1>
11791 where
11792 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11793 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11794 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11795 {
11796 #[inline]
11797 fn encode(
11798 self,
11799 encoder_: &mut ___E,
11800 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
11801 _: (),
11802 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11803 ::fidl_next::munge! {
11804 let crate::wire::DeviceWriteConfig16Request {
11805 offset,
11806 value,
11807
11808 } = out_;
11809 }
11810
11811 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11812
11813 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11814
11815 Ok(())
11816 }
11817 }
11818
11819 pub type DeviceWriteConfig16Response = ();
11821
11822 pub struct DeviceWriteConfig32Request<T0, T1> {
11824 pub offset: T0,
11825
11826 pub value: T1,
11827 }
11828
11829 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
11830 for DeviceWriteConfig32Request<T0, T1>
11831 where
11832 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11833 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11834 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11835 {
11836 #[inline]
11837 fn encode(
11838 self,
11839 encoder_: &mut ___E,
11840 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
11841 _: (),
11842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11843 ::fidl_next::munge! {
11844 let crate::wire::DeviceWriteConfig32Request {
11845 offset,
11846 value,
11847
11848 } = out_;
11849 }
11850
11851 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11852
11853 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11854
11855 Ok(())
11856 }
11857 }
11858
11859 pub type DeviceWriteConfig32Response = ();
11861
11862 pub struct DeviceGetCapabilitiesRequest<T0> {
11864 pub id: T0,
11865 }
11866
11867 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
11868 for DeviceGetCapabilitiesRequest<T0>
11869 where
11870 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11871 T0: ::fidl_next::Encode<crate::wire::CapabilityId, ___E>,
11872 {
11873 #[inline]
11874 fn encode(
11875 self,
11876 encoder_: &mut ___E,
11877 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
11878 _: (),
11879 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11880 ::fidl_next::munge! {
11881 let crate::wire::DeviceGetCapabilitiesRequest {
11882 id,
11883
11884 } = out_;
11885 }
11886
11887 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11888
11889 Ok(())
11890 }
11891 }
11892
11893 pub struct DeviceGetCapabilitiesResponse<T0> {
11895 pub offsets: T0,
11896 }
11897
11898 unsafe impl<___E, T0>
11899 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
11900 for DeviceGetCapabilitiesResponse<T0>
11901 where
11902 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11903 ___E: ::fidl_next::Encoder,
11904 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11905 {
11906 #[inline]
11907 fn encode(
11908 self,
11909 encoder_: &mut ___E,
11910 out_: &mut ::core::mem::MaybeUninit<
11911 crate::wire::DeviceGetCapabilitiesResponse<'static>,
11912 >,
11913 _: (),
11914 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11915 ::fidl_next::munge! {
11916 let crate::wire::DeviceGetCapabilitiesResponse {
11917 offsets,
11918
11919 } = out_;
11920 }
11921
11922 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11923
11924 Ok(())
11925 }
11926 }
11927
11928 pub struct DeviceGetExtendedCapabilitiesRequest<T0> {
11930 pub id: T0,
11931 }
11932
11933 unsafe impl<___E, T0>
11934 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
11935 for DeviceGetExtendedCapabilitiesRequest<T0>
11936 where
11937 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11938 T0: ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>,
11939 {
11940 #[inline]
11941 fn encode(
11942 self,
11943 encoder_: &mut ___E,
11944 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
11945 _: (),
11946 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11947 ::fidl_next::munge! {
11948 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
11949 id,
11950
11951 } = out_;
11952 }
11953
11954 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11955
11956 Ok(())
11957 }
11958 }
11959
11960 pub struct DeviceGetExtendedCapabilitiesResponse<T0> {
11962 pub offsets: T0,
11963 }
11964
11965 unsafe impl<___E, T0>
11966 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
11967 for DeviceGetExtendedCapabilitiesResponse<T0>
11968 where
11969 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11970 ___E: ::fidl_next::Encoder,
11971 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>, ___E>,
11972 {
11973 #[inline]
11974 fn encode(
11975 self,
11976 encoder_: &mut ___E,
11977 out_: &mut ::core::mem::MaybeUninit<
11978 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
11979 >,
11980 _: (),
11981 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11982 ::fidl_next::munge! {
11983 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
11984 offsets,
11985
11986 } = out_;
11987 }
11988
11989 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11990
11991 Ok(())
11992 }
11993 }
11994
11995 pub struct DeviceGetBtiRequest<T0> {
11997 pub index: T0,
11998 }
11999
12000 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
12001 for DeviceGetBtiRequest<T0>
12002 where
12003 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12004 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
12005 {
12006 #[inline]
12007 fn encode(
12008 self,
12009 encoder_: &mut ___E,
12010 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
12011 _: (),
12012 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12013 ::fidl_next::munge! {
12014 let crate::wire::DeviceGetBtiRequest {
12015 index,
12016
12017 } = out_;
12018 }
12019
12020 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
12021
12022 Ok(())
12023 }
12024 }
12025
12026 pub struct DeviceSetInterruptModeRequest<T0, T1> {
12028 pub mode: T0,
12029
12030 pub requested_irq_count: T1,
12031 }
12032
12033 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
12034 for DeviceSetInterruptModeRequest<T0, T1>
12035 where
12036 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12037 T0: ::fidl_next::Encode<crate::wire::InterruptMode, ___E>,
12038 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
12039 {
12040 #[inline]
12041 fn encode(
12042 self,
12043 encoder_: &mut ___E,
12044 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
12045 _: (),
12046 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12047 ::fidl_next::munge! {
12048 let crate::wire::DeviceSetInterruptModeRequest {
12049 mode,
12050 requested_irq_count,
12051
12052 } = out_;
12053 }
12054
12055 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
12056
12057 ::fidl_next::Encode::encode(
12058 self.requested_irq_count,
12059 encoder_,
12060 requested_irq_count,
12061 (),
12062 )?;
12063
12064 Ok(())
12065 }
12066 }
12067}
12068
12069pub use self::natural::*;
12070
12071pub const BASE_ADDRESS_COUNT: u32 = 6 as u32;
12072
12073pub const BASE_CONFIG_SIZE: u32 = 256 as u32;
12074
12075pub const MAX_NAME_LEN: u32 = 32 as u32;
12076
12077pub const MAX_CAPABILITIES: u32 = 32 as u32;
12078
12079pub const MAX_EXT_CAPABILITIES: u32 = 32 as u32;
12080
12081pub const MAX_DEVICES: u32 = 64 as u32;
12082
12083#[doc = " The Bus service provides information about devices on a particular bus. It\n is used by clients like lspci, not drivers.\n"]
12085#[derive(PartialEq, Debug)]
12086pub struct Bus;
12087
12088impl ::fidl_next::Discoverable for Bus {
12089 const PROTOCOL_NAME: &'static str = "fuchsia.hardware.pci.Bus";
12090}
12091
12092#[cfg(target_os = "fuchsia")]
12093impl ::fidl_next::HasTransport for Bus {
12094 type Transport = ::fidl_next::fuchsia::zx::Channel;
12095}
12096
12097pub mod bus {
12098 pub mod prelude {
12099 pub use crate::{
12100 Bus, BusClientHandler, BusLocalClientHandler, BusLocalServerHandler, BusServerHandler,
12101 bus,
12102 };
12103
12104 pub use crate::natural::BusGetDevicesResponse;
12105
12106 pub use crate::natural::BusGetHostBridgeInfoResponse;
12107
12108 pub use crate::natural::BusReadBarRequest;
12109
12110 pub use crate::natural::BusReadBarResponse;
12111 }
12112
12113 pub struct GetHostBridgeInfo;
12114
12115 impl ::fidl_next::Method for GetHostBridgeInfo {
12116 const ORDINAL: u64 = 4175032687054816861;
12117 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12118 ::fidl_next::protocol::Flexibility::Strict;
12119
12120 type Protocol = crate::Bus;
12121
12122 type Request = ::fidl_next::wire::EmptyMessageBody;
12123 }
12124
12125 impl ::fidl_next::TwoWayMethod for GetHostBridgeInfo {
12126 type Response =
12127 ::fidl_next::wire::Strict<crate::wire::BusGetHostBridgeInfoResponse<'static>>;
12128 }
12129
12130 impl<___R> ::fidl_next::Respond<___R> for GetHostBridgeInfo {
12131 type Output = ::fidl_next::Strict<crate::generic::BusGetHostBridgeInfoResponse<___R>>;
12132
12133 fn respond(response: ___R) -> Self::Output {
12134 ::fidl_next::Strict(crate::generic::BusGetHostBridgeInfoResponse { info: response })
12135 }
12136 }
12137
12138 pub struct GetDevices;
12139
12140 impl ::fidl_next::Method for GetDevices {
12141 const ORDINAL: u64 = 3114700014429961362;
12142 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12143 ::fidl_next::protocol::Flexibility::Strict;
12144
12145 type Protocol = crate::Bus;
12146
12147 type Request = ::fidl_next::wire::EmptyMessageBody;
12148 }
12149
12150 impl ::fidl_next::TwoWayMethod for GetDevices {
12151 type Response = ::fidl_next::wire::Strict<crate::wire::BusGetDevicesResponse<'static>>;
12152 }
12153
12154 impl<___R> ::fidl_next::Respond<___R> for GetDevices {
12155 type Output = ::fidl_next::Strict<crate::generic::BusGetDevicesResponse<___R>>;
12156
12157 fn respond(response: ___R) -> Self::Output {
12158 ::fidl_next::Strict(crate::generic::BusGetDevicesResponse { devices: response })
12159 }
12160 }
12161
12162 pub struct ReadBar;
12163
12164 impl ::fidl_next::Method for ReadBar {
12165 const ORDINAL: u64 = 8759283232091687008;
12166 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12167 ::fidl_next::protocol::Flexibility::Strict;
12168
12169 type Protocol = crate::Bus;
12170
12171 type Request = crate::wire::BusReadBarRequest;
12172 }
12173
12174 impl ::fidl_next::TwoWayMethod for ReadBar {
12175 type Response = ::fidl_next::wire::Result<
12176 'static,
12177 crate::wire::BusReadBarResponse<'static>,
12178 ::fidl_next::wire::fuchsia::Status,
12179 >;
12180 }
12181
12182 impl<___R> ::fidl_next::Respond<___R> for ReadBar {
12183 type Output = ::core::result::Result<
12184 crate::generic::BusReadBarResponse<___R>,
12185 ::fidl_next::never::Never,
12186 >;
12187
12188 fn respond(response: ___R) -> Self::Output {
12189 ::core::result::Result::Ok(crate::generic::BusReadBarResponse { buffer: response })
12190 }
12191 }
12192
12193 impl<___R> ::fidl_next::RespondErr<___R> for ReadBar {
12194 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12195
12196 fn respond_err(response: ___R) -> Self::Output {
12197 ::core::result::Result::Err(response)
12198 }
12199 }
12200
12201 mod ___detail {
12202 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Bus
12203 where
12204 ___T: ::fidl_next::Transport,
12205 {
12206 type Client = BusClient<___T>;
12207 type Server = BusServer<___T>;
12208 }
12209
12210 #[repr(transparent)]
12212 pub struct BusClient<___T: ::fidl_next::Transport> {
12213 #[allow(dead_code)]
12214 client: ::fidl_next::protocol::Client<___T>,
12215 }
12216
12217 impl<___T> BusClient<___T>
12218 where
12219 ___T: ::fidl_next::Transport,
12220 {
12221 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12222 pub fn get_host_bridge_info(
12223 &self,
12224 ) -> ::fidl_next::TwoWayFuture<'_, super::GetHostBridgeInfo, ___T> {
12225 ::fidl_next::TwoWayFuture::from_untyped(
12226 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12227 4175032687054816861,
12228 <super::GetHostBridgeInfo as ::fidl_next::Method>::FLEXIBILITY,
12229 (),
12230 ),
12231 )
12232 }
12233
12234 #[doc = " Retrieve all Devices on the Bus.\n"]
12235 pub fn get_devices(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetDevices, ___T> {
12236 ::fidl_next::TwoWayFuture::from_untyped(
12237 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12238 3114700014429961362,
12239 <super::GetDevices as ::fidl_next::Method>::FLEXIBILITY,
12240 (),
12241 ),
12242 )
12243 }
12244
12245 #[doc = " Read from a Device\'s base address register (BAR). The BAR must be an MMIO type.\n\n Parameters\n |device|: The address of the device to read from.\n |bar_id|: The ID of the BAR to read.\n |offset|: The offset, in bytes, to start the read (default: 0 bytes).\n |size|: The size of the read (default: 128 bytes). The max size for a\n read is |READBAR_MAX_SIZE|.\n\n Errors:\n |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.\n |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid, or offset / size combined\n are invalid for the given BAR\'s size.\n |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.\n"]
12246 pub fn read_bar(
12247 &self,
12248
12249 device: impl ::fidl_next::Encode<
12250 crate::wire::Address,
12251 <___T as ::fidl_next::Transport>::SendBuffer,
12252 >,
12253
12254 bar_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
12255
12256 offset: impl ::fidl_next::Encode<
12257 ::fidl_next::wire::Uint64,
12258 <___T as ::fidl_next::Transport>::SendBuffer,
12259 >,
12260
12261 size: impl ::fidl_next::Encode<
12262 ::fidl_next::wire::Uint64,
12263 <___T as ::fidl_next::Transport>::SendBuffer,
12264 >,
12265 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12266 where
12267 <___T as ::fidl_next::Transport>::SendBuffer:
12268 ::fidl_next::encoder::InternalHandleEncoder,
12269 {
12270 self.read_bar_with(crate::generic::BusReadBarRequest {
12271 device,
12272
12273 bar_id,
12274
12275 offset,
12276
12277 size,
12278 })
12279 }
12280
12281 #[doc = " Read from a Device\'s base address register (BAR). The BAR must be an MMIO type.\n\n Parameters\n |device|: The address of the device to read from.\n |bar_id|: The ID of the BAR to read.\n |offset|: The offset, in bytes, to start the read (default: 0 bytes).\n |size|: The size of the read (default: 128 bytes). The max size for a\n read is |READBAR_MAX_SIZE|.\n\n Errors:\n |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.\n |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid, or offset / size combined\n are invalid for the given BAR\'s size.\n |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.\n"]
12282 pub fn read_bar_with<___R>(
12283 &self,
12284 request: ___R,
12285 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12286 where
12287 ___R: ::fidl_next::Encode<
12288 crate::wire::BusReadBarRequest,
12289 <___T as ::fidl_next::Transport>::SendBuffer,
12290 >,
12291 {
12292 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12293 8759283232091687008,
12294 <super::ReadBar as ::fidl_next::Method>::FLEXIBILITY,
12295 request,
12296 ))
12297 }
12298 }
12299
12300 #[repr(transparent)]
12302 pub struct BusServer<___T: ::fidl_next::Transport> {
12303 server: ::fidl_next::protocol::Server<___T>,
12304 }
12305
12306 impl<___T> BusServer<___T> where ___T: ::fidl_next::Transport {}
12307 }
12308}
12309
12310#[diagnostic::on_unimplemented(
12311 note = "If {Self} implements the non-local BusClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12312)]
12313
12314pub trait BusLocalClientHandler<
12318 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12319 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12320>
12321{
12322}
12323
12324impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Bus
12325where
12326 ___H: BusLocalClientHandler<___T>,
12327 ___T: ::fidl_next::Transport,
12328{
12329 async fn on_event(
12330 handler: &mut ___H,
12331 mut message: ::fidl_next::Message<___T>,
12332 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12333 match *message.header().ordinal {
12334 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12335 }
12336 }
12337}
12338
12339#[diagnostic::on_unimplemented(
12340 note = "If {Self} implements the non-local BusServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12341)]
12342
12343pub trait BusLocalServerHandler<
12347 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12348 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12349>
12350{
12351 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12352 fn get_host_bridge_info(
12353 &mut self,
12354
12355 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12356 ) -> impl ::core::future::Future<Output = ()>;
12357
12358 #[doc = " Retrieve all Devices on the Bus.\n"]
12359 fn get_devices(
12360 &mut self,
12361
12362 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12363 ) -> impl ::core::future::Future<Output = ()>;
12364
12365 #[doc = " Read from a Device\'s base address register (BAR). The BAR must be an MMIO type.\n\n Parameters\n |device|: The address of the device to read from.\n |bar_id|: The ID of the BAR to read.\n |offset|: The offset, in bytes, to start the read (default: 0 bytes).\n |size|: The size of the read (default: 128 bytes). The max size for a\n read is |READBAR_MAX_SIZE|.\n\n Errors:\n |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.\n |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid, or offset / size combined\n are invalid for the given BAR\'s size.\n |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.\n"]
12366 fn read_bar(
12367 &mut self,
12368
12369 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12370
12371 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12372 ) -> impl ::core::future::Future<Output = ()>;
12373}
12374
12375impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Bus
12376where
12377 ___H: BusLocalServerHandler<___T>,
12378 ___T: ::fidl_next::Transport,
12379 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12380 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12381 Constraint = (),
12382 >,
12383{
12384 async fn on_one_way(
12385 handler: &mut ___H,
12386 mut message: ::fidl_next::Message<___T>,
12387 ) -> ::core::result::Result<
12388 (),
12389 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12390 > {
12391 match *message.header().ordinal {
12392 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12393 }
12394 }
12395
12396 async fn on_two_way(
12397 handler: &mut ___H,
12398 mut message: ::fidl_next::Message<___T>,
12399 responder: ::fidl_next::protocol::Responder<___T>,
12400 ) -> ::core::result::Result<
12401 (),
12402 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12403 > {
12404 match *message.header().ordinal {
12405 4175032687054816861 => {
12406 let responder = ::fidl_next::Responder::from_untyped(responder);
12407
12408 handler.get_host_bridge_info(responder).await;
12409 Ok(())
12410 }
12411
12412 3114700014429961362 => {
12413 let responder = ::fidl_next::Responder::from_untyped(responder);
12414
12415 handler.get_devices(responder).await;
12416 Ok(())
12417 }
12418
12419 8759283232091687008 => {
12420 let responder = ::fidl_next::Responder::from_untyped(responder);
12421
12422 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12423 Ok(decoded) => {
12424 handler
12425 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12426 .await;
12427 Ok(())
12428 }
12429 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12430 ordinal: 8759283232091687008,
12431 error,
12432 }),
12433 }
12434 }
12435
12436 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12437 }
12438 }
12439}
12440
12441pub trait BusClientHandler<
12445 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12446 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12447>
12448{
12449}
12450
12451impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Bus
12452where
12453 ___H: BusClientHandler<___T> + ::core::marker::Send,
12454 ___T: ::fidl_next::Transport,
12455{
12456 async fn on_event(
12457 handler: &mut ___H,
12458 mut message: ::fidl_next::Message<___T>,
12459 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12460 match *message.header().ordinal {
12461 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12462 }
12463 }
12464}
12465
12466pub trait BusServerHandler<
12470 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12471 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12472>
12473{
12474 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12475 fn get_host_bridge_info(
12476 &mut self,
12477
12478 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12479 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12480
12481 #[doc = " Retrieve all Devices on the Bus.\n"]
12482 fn get_devices(
12483 &mut self,
12484
12485 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12486 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12487
12488 #[doc = " Read from a Device\'s base address register (BAR). The BAR must be an MMIO type.\n\n Parameters\n |device|: The address of the device to read from.\n |bar_id|: The ID of the BAR to read.\n |offset|: The offset, in bytes, to start the read (default: 0 bytes).\n |size|: The size of the read (default: 128 bytes). The max size for a\n read is |READBAR_MAX_SIZE|.\n\n Errors:\n |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.\n |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid, or offset / size combined\n are invalid for the given BAR\'s size.\n |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.\n"]
12489 fn read_bar(
12490 &mut self,
12491
12492 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12493
12494 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12495 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12496}
12497
12498impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Bus
12499where
12500 ___H: BusServerHandler<___T> + ::core::marker::Send,
12501 ___T: ::fidl_next::Transport,
12502 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12503 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12504 Constraint = (),
12505 >,
12506{
12507 async fn on_one_way(
12508 handler: &mut ___H,
12509 mut message: ::fidl_next::Message<___T>,
12510 ) -> ::core::result::Result<
12511 (),
12512 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12513 > {
12514 match *message.header().ordinal {
12515 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12516 }
12517 }
12518
12519 async fn on_two_way(
12520 handler: &mut ___H,
12521 mut message: ::fidl_next::Message<___T>,
12522 responder: ::fidl_next::protocol::Responder<___T>,
12523 ) -> ::core::result::Result<
12524 (),
12525 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12526 > {
12527 match *message.header().ordinal {
12528 4175032687054816861 => {
12529 let responder = ::fidl_next::Responder::from_untyped(responder);
12530
12531 handler.get_host_bridge_info(responder).await;
12532 Ok(())
12533 }
12534
12535 3114700014429961362 => {
12536 let responder = ::fidl_next::Responder::from_untyped(responder);
12537
12538 handler.get_devices(responder).await;
12539 Ok(())
12540 }
12541
12542 8759283232091687008 => {
12543 let responder = ::fidl_next::Responder::from_untyped(responder);
12544
12545 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12546 Ok(decoded) => {
12547 handler
12548 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12549 .await;
12550 Ok(())
12551 }
12552 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12553 ordinal: 8759283232091687008,
12554 error,
12555 }),
12556 }
12557 }
12558
12559 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12560 }
12561 }
12562}
12563
12564impl<___T> BusClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
12565
12566impl<___H, ___T> BusLocalClientHandler<___T> for ::fidl_next::Local<___H>
12567where
12568 ___H: BusClientHandler<___T>,
12569 ___T: ::fidl_next::Transport,
12570{
12571}
12572
12573impl<___H, ___T> BusLocalServerHandler<___T> for ::fidl_next::Local<___H>
12574where
12575 ___H: BusServerHandler<___T>,
12576 ___T: ::fidl_next::Transport,
12577{
12578 async fn get_host_bridge_info(
12579 &mut self,
12580
12581 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12582 ) {
12583 ___H::get_host_bridge_info(&mut self.0, responder).await
12584 }
12585
12586 async fn get_devices(&mut self, responder: ::fidl_next::Responder<bus::GetDevices, ___T>) {
12587 ___H::get_devices(&mut self.0, responder).await
12588 }
12589
12590 async fn read_bar(
12591 &mut self,
12592
12593 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12594
12595 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12596 ) {
12597 ___H::read_bar(&mut self.0, request, responder).await
12598 }
12599}
12600
12601pub const EXTENDED_CONFIG_SIZE: u32 = 4096 as u32;
12602
12603pub const MAX_BAR_COUNT: u8 = 6 as u8;
12604
12605pub const READBAR_MAX_SIZE: u32 = 1024 as u32;
12606
12607pub const STATUS_DEVSEL_MASK: crate::natural::Status =
12608 crate::natural::Status::from_bits_retain(1536);