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, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
400 pub struct BoardConfiguration {
401 pub use_intx_workaround: ::core::option::Option<crate::natural::UseIntxWorkaroundType>,
402 }
403
404 impl BoardConfiguration {
405 fn __max_ordinal(&self) -> usize {
406 if self.use_intx_workaround.is_some() {
407 return 1;
408 }
409
410 0
411 }
412 }
413
414 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
415 for BoardConfiguration
416 where
417 ___E: ::fidl_next::Encoder + ?Sized,
418 {
419 #[inline]
420 fn encode(
421 mut self,
422 encoder: &mut ___E,
423 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
424 _: (),
425 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
426 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
427
428 let max_ord = self.__max_ordinal();
429
430 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
431 ::fidl_next::Wire::zero_padding(&mut out);
432
433 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
434 ::fidl_next::wire::Envelope,
435 >(encoder, max_ord);
436
437 for i in 1..=max_ord {
438 match i {
439 1 => {
440 if let Some(value) = self.use_intx_workaround.take() {
441 ::fidl_next::wire::Envelope::encode_value::<
442 crate::wire::UseIntxWorkaroundType,
443 ___E,
444 >(
445 value, preallocated.encoder, &mut out, ()
446 )?;
447 } else {
448 ::fidl_next::wire::Envelope::encode_zero(&mut out)
449 }
450 }
451
452 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
453 }
454 unsafe {
455 preallocated.write_next(out.assume_init_ref());
456 }
457 }
458
459 ::fidl_next::wire::Table::encode_len(table, max_ord);
460
461 Ok(())
462 }
463 }
464
465 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
466 for &'a BoardConfiguration
467 where
468 ___E: ::fidl_next::Encoder + ?Sized,
469 {
470 #[inline]
471 fn encode(
472 self,
473 encoder: &mut ___E,
474 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
475 _: (),
476 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
477 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
478
479 let max_ord = self.__max_ordinal();
480
481 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
482 ::fidl_next::Wire::zero_padding(&mut out);
483
484 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
485 ::fidl_next::wire::Envelope,
486 >(encoder, max_ord);
487
488 for i in 1..=max_ord {
489 match i {
490 1 => {
491 if let Some(value) = &self.use_intx_workaround {
492 ::fidl_next::wire::Envelope::encode_value::<
493 crate::wire::UseIntxWorkaroundType,
494 ___E,
495 >(
496 value, preallocated.encoder, &mut out, ()
497 )?;
498 } else {
499 ::fidl_next::wire::Envelope::encode_zero(&mut out)
500 }
501 }
502
503 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
504 }
505 unsafe {
506 preallocated.write_next(out.assume_init_ref());
507 }
508 }
509
510 ::fidl_next::wire::Table::encode_len(table, max_ord);
511
512 Ok(())
513 }
514 }
515
516 impl<'de> ::fidl_next::FromWire<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
517 #[inline]
518 fn from_wire(wire_: crate::wire::BoardConfiguration<'de>) -> Self {
519 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
520
521 let use_intx_workaround = wire_.table.get(1);
522
523 Self {
524 use_intx_workaround: use_intx_workaround.map(|envelope| {
525 ::fidl_next::FromWire::from_wire(unsafe {
526 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
527 })
528 }),
529 }
530 }
531 }
532
533 impl<'de> ::fidl_next::FromWireRef<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
534 #[inline]
535 fn from_wire_ref(wire: &crate::wire::BoardConfiguration<'de>) -> Self {
536 Self {
537 use_intx_workaround: wire.table.get(1).map(|envelope| {
538 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
539 envelope.deref_unchecked::<crate::wire::UseIntxWorkaroundType>()
540 })
541 }),
542 }
543 }
544 }
545
546 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
547 pub struct HostBridgeInfo {
548 pub name: ::std::string::String,
549
550 pub start_bus_number: u8,
551
552 pub end_bus_number: u8,
553
554 pub segment_group: u16,
555 }
556
557 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E> for HostBridgeInfo
558 where
559 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
560 ___E: ::fidl_next::Encoder,
561 {
562 #[inline]
563 fn encode(
564 self,
565 encoder_: &mut ___E,
566 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
567 _: (),
568 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
569 ::fidl_next::munge! {
570 let crate::wire::HostBridgeInfo {
571 name,
572 start_bus_number,
573 end_bus_number,
574 segment_group,
575
576 } = out_;
577 }
578
579 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
580
581 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
582 ::fidl_next::Constrained::validate(_field, 32)?;
583
584 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
585
586 let mut _field =
587 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
588
589 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
590
591 let mut _field =
592 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
593
594 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
595
596 let mut _field =
597 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
598
599 Ok(())
600 }
601 }
602
603 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
604 for &'a HostBridgeInfo
605 where
606 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
607 ___E: ::fidl_next::Encoder,
608 {
609 #[inline]
610 fn encode(
611 self,
612 encoder_: &mut ___E,
613 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
614 _: (),
615 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
616 ::fidl_next::munge! {
617 let crate::wire::HostBridgeInfo {
618 name,
619 start_bus_number,
620 end_bus_number,
621 segment_group,
622
623 } = out_;
624 }
625
626 ::fidl_next::Encode::encode(&self.name, encoder_, name, 32)?;
627
628 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
629 ::fidl_next::Constrained::validate(_field, 32)?;
630
631 ::fidl_next::Encode::encode(&self.start_bus_number, encoder_, start_bus_number, ())?;
632
633 let mut _field =
634 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
635
636 ::fidl_next::Encode::encode(&self.end_bus_number, encoder_, end_bus_number, ())?;
637
638 let mut _field =
639 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
640
641 ::fidl_next::Encode::encode(&self.segment_group, encoder_, segment_group, ())?;
642
643 let mut _field =
644 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
645
646 Ok(())
647 }
648 }
649
650 unsafe impl<___E>
651 ::fidl_next::EncodeOption<
652 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
653 ___E,
654 > for HostBridgeInfo
655 where
656 ___E: ::fidl_next::Encoder + ?Sized,
657 HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
658 {
659 #[inline]
660 fn encode_option(
661 this: ::core::option::Option<Self>,
662 encoder: &mut ___E,
663 out: &mut ::core::mem::MaybeUninit<
664 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
665 >,
666 _: (),
667 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
668 if let Some(inner) = this {
669 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
670 ::fidl_next::wire::Box::encode_present(out);
671 } else {
672 ::fidl_next::wire::Box::encode_absent(out);
673 }
674
675 Ok(())
676 }
677 }
678
679 unsafe impl<'a, ___E>
680 ::fidl_next::EncodeOption<
681 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
682 ___E,
683 > for &'a HostBridgeInfo
684 where
685 ___E: ::fidl_next::Encoder + ?Sized,
686 &'a HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
687 {
688 #[inline]
689 fn encode_option(
690 this: ::core::option::Option<Self>,
691 encoder: &mut ___E,
692 out: &mut ::core::mem::MaybeUninit<
693 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
694 >,
695 _: (),
696 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
697 if let Some(inner) = this {
698 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
699 ::fidl_next::wire::Box::encode_present(out);
700 } else {
701 ::fidl_next::wire::Box::encode_absent(out);
702 }
703
704 Ok(())
705 }
706 }
707
708 impl<'de> ::fidl_next::FromWire<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
709 #[inline]
710 fn from_wire(wire: crate::wire::HostBridgeInfo<'de>) -> Self {
711 Self {
712 name: ::fidl_next::FromWire::from_wire(wire.name),
713
714 start_bus_number: ::fidl_next::FromWire::from_wire(wire.start_bus_number),
715
716 end_bus_number: ::fidl_next::FromWire::from_wire(wire.end_bus_number),
717
718 segment_group: ::fidl_next::FromWire::from_wire(wire.segment_group),
719 }
720 }
721 }
722
723 impl<'de> ::fidl_next::FromWireRef<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
724 #[inline]
725 fn from_wire_ref(wire: &crate::wire::HostBridgeInfo<'de>) -> Self {
726 Self {
727 name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
728
729 start_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_bus_number),
730
731 end_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.end_bus_number),
732
733 segment_group: ::fidl_next::FromWireRef::from_wire_ref(&wire.segment_group),
734 }
735 }
736 }
737
738 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
739 pub struct BusGetHostBridgeInfoResponse {
740 pub info: crate::natural::HostBridgeInfo,
741 }
742
743 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
744 for BusGetHostBridgeInfoResponse
745 where
746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
747 ___E: ::fidl_next::Encoder,
748 {
749 #[inline]
750 fn encode(
751 self,
752 encoder_: &mut ___E,
753 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
754 _: (),
755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
756 ::fidl_next::munge! {
757 let crate::wire::BusGetHostBridgeInfoResponse {
758 info,
759
760 } = out_;
761 }
762
763 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
764
765 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
766
767 Ok(())
768 }
769 }
770
771 unsafe impl<'a, ___E>
772 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
773 for &'a BusGetHostBridgeInfoResponse
774 where
775 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
776 ___E: ::fidl_next::Encoder,
777 {
778 #[inline]
779 fn encode(
780 self,
781 encoder_: &mut ___E,
782 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
783 _: (),
784 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
785 ::fidl_next::munge! {
786 let crate::wire::BusGetHostBridgeInfoResponse {
787 info,
788
789 } = out_;
790 }
791
792 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
793
794 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
795
796 Ok(())
797 }
798 }
799
800 unsafe impl<___E>
801 ::fidl_next::EncodeOption<
802 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
803 ___E,
804 > for BusGetHostBridgeInfoResponse
805 where
806 ___E: ::fidl_next::Encoder + ?Sized,
807 BusGetHostBridgeInfoResponse:
808 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>,
809 {
810 #[inline]
811 fn encode_option(
812 this: ::core::option::Option<Self>,
813 encoder: &mut ___E,
814 out: &mut ::core::mem::MaybeUninit<
815 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
816 >,
817 _: (),
818 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
819 if let Some(inner) = this {
820 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
821 ::fidl_next::wire::Box::encode_present(out);
822 } else {
823 ::fidl_next::wire::Box::encode_absent(out);
824 }
825
826 Ok(())
827 }
828 }
829
830 unsafe impl<'a, ___E>
831 ::fidl_next::EncodeOption<
832 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
833 ___E,
834 > for &'a BusGetHostBridgeInfoResponse
835 where
836 ___E: ::fidl_next::Encoder + ?Sized,
837 &'a BusGetHostBridgeInfoResponse:
838 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>,
839 {
840 #[inline]
841 fn encode_option(
842 this: ::core::option::Option<Self>,
843 encoder: &mut ___E,
844 out: &mut ::core::mem::MaybeUninit<
845 ::fidl_next::wire::Box<'static, crate::wire::BusGetHostBridgeInfoResponse<'static>>,
846 >,
847 _: (),
848 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
849 if let Some(inner) = this {
850 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
851 ::fidl_next::wire::Box::encode_present(out);
852 } else {
853 ::fidl_next::wire::Box::encode_absent(out);
854 }
855
856 Ok(())
857 }
858 }
859
860 impl<'de> ::fidl_next::FromWire<crate::wire::BusGetHostBridgeInfoResponse<'de>>
861 for BusGetHostBridgeInfoResponse
862 {
863 #[inline]
864 fn from_wire(wire: crate::wire::BusGetHostBridgeInfoResponse<'de>) -> Self {
865 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
866 }
867 }
868
869 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusGetHostBridgeInfoResponse<'de>>
870 for BusGetHostBridgeInfoResponse
871 {
872 #[inline]
873 fn from_wire_ref(wire: &crate::wire::BusGetHostBridgeInfoResponse<'de>) -> Self {
874 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
875 }
876 }
877
878 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
879 #[repr(C)]
880 pub struct Capability {
881 pub id: u8,
882
883 pub offset: u8,
884 }
885
886 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability
887 where
888 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
889 {
890 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Capability> = unsafe {
891 ::fidl_next::CopyOptimization::enable_if(
892 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
893 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
894 )
895 };
896
897 #[inline]
898 fn encode(
899 self,
900 encoder_: &mut ___E,
901 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
902 _: (),
903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
904 ::fidl_next::munge! {
905 let crate::wire::Capability {
906 id,
907 offset,
908
909 } = out_;
910 }
911
912 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
913
914 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
915
916 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
917
918 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
919
920 Ok(())
921 }
922 }
923
924 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for &'a Capability
925 where
926 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
927 {
928 #[inline]
929 fn encode(
930 self,
931 encoder_: &mut ___E,
932 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
933 _: (),
934 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
935 ::fidl_next::munge! {
936 let crate::wire::Capability {
937 id,
938 offset,
939
940 } = out_;
941 }
942
943 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
944
945 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
946
947 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
948
949 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
950
951 Ok(())
952 }
953 }
954
955 unsafe impl<___E>
956 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
957 for Capability
958 where
959 ___E: ::fidl_next::Encoder + ?Sized,
960 Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
961 {
962 #[inline]
963 fn encode_option(
964 this: ::core::option::Option<Self>,
965 encoder: &mut ___E,
966 out: &mut ::core::mem::MaybeUninit<
967 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
968 >,
969 _: (),
970 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
971 if let Some(inner) = this {
972 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
973 ::fidl_next::wire::Box::encode_present(out);
974 } else {
975 ::fidl_next::wire::Box::encode_absent(out);
976 }
977
978 Ok(())
979 }
980 }
981
982 unsafe impl<'a, ___E>
983 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
984 for &'a Capability
985 where
986 ___E: ::fidl_next::Encoder + ?Sized,
987 &'a Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
988 {
989 #[inline]
990 fn encode_option(
991 this: ::core::option::Option<Self>,
992 encoder: &mut ___E,
993 out: &mut ::core::mem::MaybeUninit<
994 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
995 >,
996 _: (),
997 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
998 if let Some(inner) = this {
999 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1000 ::fidl_next::wire::Box::encode_present(out);
1001 } else {
1002 ::fidl_next::wire::Box::encode_absent(out);
1003 }
1004
1005 Ok(())
1006 }
1007 }
1008
1009 impl ::fidl_next::FromWire<crate::wire::Capability> for Capability {
1010 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Capability, Self> = unsafe {
1011 ::fidl_next::CopyOptimization::enable_if(
1012 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
1013 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
1014 )
1015 };
1016
1017 #[inline]
1018 fn from_wire(wire: crate::wire::Capability) -> Self {
1019 Self {
1020 id: ::fidl_next::FromWire::from_wire(wire.id),
1021
1022 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1023 }
1024 }
1025 }
1026
1027 impl ::fidl_next::FromWireRef<crate::wire::Capability> for Capability {
1028 #[inline]
1029 fn from_wire_ref(wire: &crate::wire::Capability) -> Self {
1030 Self {
1031 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1032
1033 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1034 }
1035 }
1036 }
1037
1038 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1039 #[repr(C)]
1040 pub struct ExtendedCapability {
1041 pub id: u16,
1042
1043 pub offset: u16,
1044 }
1045
1046 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E> for ExtendedCapability
1047 where
1048 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1049 {
1050 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1051 Self,
1052 crate::wire::ExtendedCapability,
1053 > = unsafe {
1054 ::fidl_next::CopyOptimization::enable_if(
1055 true
1056
1057 && <
1058 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1059 >::COPY_OPTIMIZATION.is_enabled()
1060
1061 && <
1062 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1063 >::COPY_OPTIMIZATION.is_enabled()
1064
1065 )
1066 };
1067
1068 #[inline]
1069 fn encode(
1070 self,
1071 encoder_: &mut ___E,
1072 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1073 _: (),
1074 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1075 ::fidl_next::munge! {
1076 let crate::wire::ExtendedCapability {
1077 id,
1078 offset,
1079
1080 } = out_;
1081 }
1082
1083 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1084
1085 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1086
1087 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1088
1089 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1090
1091 Ok(())
1092 }
1093 }
1094
1095 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
1096 for &'a ExtendedCapability
1097 where
1098 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1099 {
1100 #[inline]
1101 fn encode(
1102 self,
1103 encoder_: &mut ___E,
1104 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1105 _: (),
1106 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1107 ::fidl_next::munge! {
1108 let crate::wire::ExtendedCapability {
1109 id,
1110 offset,
1111
1112 } = out_;
1113 }
1114
1115 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1116
1117 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1118
1119 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
1120
1121 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1122
1123 Ok(())
1124 }
1125 }
1126
1127 unsafe impl<___E>
1128 ::fidl_next::EncodeOption<
1129 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1130 ___E,
1131 > for ExtendedCapability
1132 where
1133 ___E: ::fidl_next::Encoder + ?Sized,
1134 ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1135 {
1136 #[inline]
1137 fn encode_option(
1138 this: ::core::option::Option<Self>,
1139 encoder: &mut ___E,
1140 out: &mut ::core::mem::MaybeUninit<
1141 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1142 >,
1143 _: (),
1144 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1145 if let Some(inner) = this {
1146 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1147 ::fidl_next::wire::Box::encode_present(out);
1148 } else {
1149 ::fidl_next::wire::Box::encode_absent(out);
1150 }
1151
1152 Ok(())
1153 }
1154 }
1155
1156 unsafe impl<'a, ___E>
1157 ::fidl_next::EncodeOption<
1158 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1159 ___E,
1160 > for &'a ExtendedCapability
1161 where
1162 ___E: ::fidl_next::Encoder + ?Sized,
1163 &'a ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1164 {
1165 #[inline]
1166 fn encode_option(
1167 this: ::core::option::Option<Self>,
1168 encoder: &mut ___E,
1169 out: &mut ::core::mem::MaybeUninit<
1170 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1171 >,
1172 _: (),
1173 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1174 if let Some(inner) = this {
1175 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1176 ::fidl_next::wire::Box::encode_present(out);
1177 } else {
1178 ::fidl_next::wire::Box::encode_absent(out);
1179 }
1180
1181 Ok(())
1182 }
1183 }
1184
1185 impl ::fidl_next::FromWire<crate::wire::ExtendedCapability> for ExtendedCapability {
1186 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1187 crate::wire::ExtendedCapability,
1188 Self,
1189 > = unsafe {
1190 ::fidl_next::CopyOptimization::enable_if(
1191 true
1192 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1193 .is_enabled()
1194 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1195 .is_enabled(),
1196 )
1197 };
1198
1199 #[inline]
1200 fn from_wire(wire: crate::wire::ExtendedCapability) -> Self {
1201 Self {
1202 id: ::fidl_next::FromWire::from_wire(wire.id),
1203
1204 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1205 }
1206 }
1207 }
1208
1209 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapability> for ExtendedCapability {
1210 #[inline]
1211 fn from_wire_ref(wire: &crate::wire::ExtendedCapability) -> Self {
1212 Self {
1213 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1214
1215 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1216 }
1217 }
1218 }
1219
1220 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1221 pub struct PciDevice {
1222 pub base_addresses: ::std::vec::Vec<crate::natural::BaseAddress>,
1223
1224 pub capabilities: ::std::vec::Vec<crate::natural::Capability>,
1225
1226 pub ext_capabilities: ::std::vec::Vec<crate::natural::ExtendedCapability>,
1227
1228 pub config: ::std::vec::Vec<u8>,
1229
1230 pub bus_id: u8,
1231
1232 pub device_id: u8,
1233
1234 pub function_id: u8,
1235 }
1236
1237 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for PciDevice
1238 where
1239 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1240 ___E: ::fidl_next::Encoder,
1241 {
1242 #[inline]
1243 fn encode(
1244 self,
1245 encoder_: &mut ___E,
1246 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
1247 _: (),
1248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1249 ::fidl_next::munge! {
1250 let crate::wire::PciDevice {
1251 base_addresses,
1252 capabilities,
1253 ext_capabilities,
1254 config,
1255 bus_id,
1256 device_id,
1257 function_id,
1258
1259 } = out_;
1260 }
1261
1262 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
1263
1264 let mut _field =
1265 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
1266 ::fidl_next::Constrained::validate(_field, (6, ()))?;
1267
1268 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
1269
1270 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
1271 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1272
1273 ::fidl_next::Encode::encode(
1274 self.ext_capabilities,
1275 encoder_,
1276 ext_capabilities,
1277 (32, ()),
1278 )?;
1279
1280 let mut _field =
1281 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
1282 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1283
1284 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
1285
1286 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
1287 ::fidl_next::Constrained::validate(_field, (256, ()))?;
1288
1289 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
1290
1291 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
1292
1293 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
1294
1295 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
1296
1297 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
1298
1299 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
1300
1301 Ok(())
1302 }
1303 }
1304
1305 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for &'a PciDevice
1306 where
1307 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1308 ___E: ::fidl_next::Encoder,
1309 {
1310 #[inline]
1311 fn encode(
1312 self,
1313 encoder_: &mut ___E,
1314 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
1315 _: (),
1316 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1317 ::fidl_next::munge! {
1318 let crate::wire::PciDevice {
1319 base_addresses,
1320 capabilities,
1321 ext_capabilities,
1322 config,
1323 bus_id,
1324 device_id,
1325 function_id,
1326
1327 } = out_;
1328 }
1329
1330 ::fidl_next::Encode::encode(&self.base_addresses, encoder_, base_addresses, (6, ()))?;
1331
1332 let mut _field =
1333 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
1334 ::fidl_next::Constrained::validate(_field, (6, ()))?;
1335
1336 ::fidl_next::Encode::encode(&self.capabilities, encoder_, capabilities, (32, ()))?;
1337
1338 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
1339 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1340
1341 ::fidl_next::Encode::encode(
1342 &self.ext_capabilities,
1343 encoder_,
1344 ext_capabilities,
1345 (32, ()),
1346 )?;
1347
1348 let mut _field =
1349 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
1350 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1351
1352 ::fidl_next::Encode::encode(&self.config, encoder_, config, (256, ()))?;
1353
1354 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
1355 ::fidl_next::Constrained::validate(_field, (256, ()))?;
1356
1357 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
1358
1359 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
1360
1361 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
1362
1363 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
1364
1365 ::fidl_next::Encode::encode(&self.function_id, encoder_, function_id, ())?;
1366
1367 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
1368
1369 Ok(())
1370 }
1371 }
1372
1373 unsafe impl<___E>
1374 ::fidl_next::EncodeOption<
1375 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1376 ___E,
1377 > for PciDevice
1378 where
1379 ___E: ::fidl_next::Encoder + ?Sized,
1380 PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
1381 {
1382 #[inline]
1383 fn encode_option(
1384 this: ::core::option::Option<Self>,
1385 encoder: &mut ___E,
1386 out: &mut ::core::mem::MaybeUninit<
1387 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1388 >,
1389 _: (),
1390 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1391 if let Some(inner) = this {
1392 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1393 ::fidl_next::wire::Box::encode_present(out);
1394 } else {
1395 ::fidl_next::wire::Box::encode_absent(out);
1396 }
1397
1398 Ok(())
1399 }
1400 }
1401
1402 unsafe impl<'a, ___E>
1403 ::fidl_next::EncodeOption<
1404 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1405 ___E,
1406 > for &'a PciDevice
1407 where
1408 ___E: ::fidl_next::Encoder + ?Sized,
1409 &'a PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
1410 {
1411 #[inline]
1412 fn encode_option(
1413 this: ::core::option::Option<Self>,
1414 encoder: &mut ___E,
1415 out: &mut ::core::mem::MaybeUninit<
1416 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
1417 >,
1418 _: (),
1419 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1420 if let Some(inner) = this {
1421 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1422 ::fidl_next::wire::Box::encode_present(out);
1423 } else {
1424 ::fidl_next::wire::Box::encode_absent(out);
1425 }
1426
1427 Ok(())
1428 }
1429 }
1430
1431 impl<'de> ::fidl_next::FromWire<crate::wire::PciDevice<'de>> for PciDevice {
1432 #[inline]
1433 fn from_wire(wire: crate::wire::PciDevice<'de>) -> Self {
1434 Self {
1435 base_addresses: ::fidl_next::FromWire::from_wire(wire.base_addresses),
1436
1437 capabilities: ::fidl_next::FromWire::from_wire(wire.capabilities),
1438
1439 ext_capabilities: ::fidl_next::FromWire::from_wire(wire.ext_capabilities),
1440
1441 config: ::fidl_next::FromWire::from_wire(wire.config),
1442
1443 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
1444
1445 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
1446
1447 function_id: ::fidl_next::FromWire::from_wire(wire.function_id),
1448 }
1449 }
1450 }
1451
1452 impl<'de> ::fidl_next::FromWireRef<crate::wire::PciDevice<'de>> for PciDevice {
1453 #[inline]
1454 fn from_wire_ref(wire: &crate::wire::PciDevice<'de>) -> Self {
1455 Self {
1456 base_addresses: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_addresses),
1457
1458 capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.capabilities),
1459
1460 ext_capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.ext_capabilities),
1461
1462 config: ::fidl_next::FromWireRef::from_wire_ref(&wire.config),
1463
1464 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
1465
1466 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
1467
1468 function_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.function_id),
1469 }
1470 }
1471 }
1472
1473 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1474 pub struct BusGetDevicesResponse {
1475 pub devices: ::std::vec::Vec<crate::natural::PciDevice>,
1476 }
1477
1478 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
1479 for BusGetDevicesResponse
1480 where
1481 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1482 ___E: ::fidl_next::Encoder,
1483 {
1484 #[inline]
1485 fn encode(
1486 self,
1487 encoder_: &mut ___E,
1488 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
1489 _: (),
1490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1491 ::fidl_next::munge! {
1492 let crate::wire::BusGetDevicesResponse {
1493 devices,
1494
1495 } = out_;
1496 }
1497
1498 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
1499
1500 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
1501 ::fidl_next::Constrained::validate(_field, (64, ()))?;
1502
1503 Ok(())
1504 }
1505 }
1506
1507 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
1508 for &'a BusGetDevicesResponse
1509 where
1510 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1511 ___E: ::fidl_next::Encoder,
1512 {
1513 #[inline]
1514 fn encode(
1515 self,
1516 encoder_: &mut ___E,
1517 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
1518 _: (),
1519 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1520 ::fidl_next::munge! {
1521 let crate::wire::BusGetDevicesResponse {
1522 devices,
1523
1524 } = out_;
1525 }
1526
1527 ::fidl_next::Encode::encode(&self.devices, encoder_, devices, (64, ()))?;
1528
1529 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
1530 ::fidl_next::Constrained::validate(_field, (64, ()))?;
1531
1532 Ok(())
1533 }
1534 }
1535
1536 unsafe impl<___E>
1537 ::fidl_next::EncodeOption<
1538 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1539 ___E,
1540 > for BusGetDevicesResponse
1541 where
1542 ___E: ::fidl_next::Encoder + ?Sized,
1543 BusGetDevicesResponse:
1544 ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>,
1545 {
1546 #[inline]
1547 fn encode_option(
1548 this: ::core::option::Option<Self>,
1549 encoder: &mut ___E,
1550 out: &mut ::core::mem::MaybeUninit<
1551 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1552 >,
1553 _: (),
1554 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1555 if let Some(inner) = this {
1556 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1557 ::fidl_next::wire::Box::encode_present(out);
1558 } else {
1559 ::fidl_next::wire::Box::encode_absent(out);
1560 }
1561
1562 Ok(())
1563 }
1564 }
1565
1566 unsafe impl<'a, ___E>
1567 ::fidl_next::EncodeOption<
1568 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1569 ___E,
1570 > for &'a BusGetDevicesResponse
1571 where
1572 ___E: ::fidl_next::Encoder + ?Sized,
1573 &'a BusGetDevicesResponse:
1574 ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>,
1575 {
1576 #[inline]
1577 fn encode_option(
1578 this: ::core::option::Option<Self>,
1579 encoder: &mut ___E,
1580 out: &mut ::core::mem::MaybeUninit<
1581 ::fidl_next::wire::Box<'static, crate::wire::BusGetDevicesResponse<'static>>,
1582 >,
1583 _: (),
1584 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1585 if let Some(inner) = this {
1586 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1587 ::fidl_next::wire::Box::encode_present(out);
1588 } else {
1589 ::fidl_next::wire::Box::encode_absent(out);
1590 }
1591
1592 Ok(())
1593 }
1594 }
1595
1596 impl<'de> ::fidl_next::FromWire<crate::wire::BusGetDevicesResponse<'de>> for BusGetDevicesResponse {
1597 #[inline]
1598 fn from_wire(wire: crate::wire::BusGetDevicesResponse<'de>) -> Self {
1599 Self { devices: ::fidl_next::FromWire::from_wire(wire.devices) }
1600 }
1601 }
1602
1603 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusGetDevicesResponse<'de>>
1604 for BusGetDevicesResponse
1605 {
1606 #[inline]
1607 fn from_wire_ref(wire: &crate::wire::BusGetDevicesResponse<'de>) -> Self {
1608 Self { devices: ::fidl_next::FromWireRef::from_wire_ref(&wire.devices) }
1609 }
1610 }
1611
1612 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1613 pub struct BusReadBarRequest {
1614 pub device: crate::natural::Address,
1615
1616 pub bar_id: u8,
1617
1618 pub offset: u64,
1619
1620 pub size: u64,
1621 }
1622
1623 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E> for BusReadBarRequest
1624 where
1625 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1626 {
1627 #[inline]
1628 fn encode(
1629 self,
1630 encoder_: &mut ___E,
1631 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
1632 _: (),
1633 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1634 ::fidl_next::munge! {
1635 let crate::wire::BusReadBarRequest {
1636 device,
1637 bar_id,
1638 offset,
1639 size,
1640
1641 } = out_;
1642 }
1643
1644 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
1645
1646 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
1647
1648 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
1649
1650 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
1651
1652 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1653
1654 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1655
1656 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
1657
1658 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
1659
1660 Ok(())
1661 }
1662 }
1663
1664 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>
1665 for &'a BusReadBarRequest
1666 where
1667 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1668 {
1669 #[inline]
1670 fn encode(
1671 self,
1672 encoder_: &mut ___E,
1673 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
1674 _: (),
1675 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1676 ::fidl_next::munge! {
1677 let crate::wire::BusReadBarRequest {
1678 device,
1679 bar_id,
1680 offset,
1681 size,
1682
1683 } = out_;
1684 }
1685
1686 ::fidl_next::Encode::encode(&self.device, encoder_, device, ())?;
1687
1688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
1689
1690 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
1691
1692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
1693
1694 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
1695
1696 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1697
1698 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
1699
1700 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
1701
1702 Ok(())
1703 }
1704 }
1705
1706 unsafe impl<___E>
1707 ::fidl_next::EncodeOption<
1708 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1709 ___E,
1710 > for BusReadBarRequest
1711 where
1712 ___E: ::fidl_next::Encoder + ?Sized,
1713 BusReadBarRequest: ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>,
1714 {
1715 #[inline]
1716 fn encode_option(
1717 this: ::core::option::Option<Self>,
1718 encoder: &mut ___E,
1719 out: &mut ::core::mem::MaybeUninit<
1720 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1721 >,
1722 _: (),
1723 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1724 if let Some(inner) = this {
1725 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1726 ::fidl_next::wire::Box::encode_present(out);
1727 } else {
1728 ::fidl_next::wire::Box::encode_absent(out);
1729 }
1730
1731 Ok(())
1732 }
1733 }
1734
1735 unsafe impl<'a, ___E>
1736 ::fidl_next::EncodeOption<
1737 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1738 ___E,
1739 > for &'a BusReadBarRequest
1740 where
1741 ___E: ::fidl_next::Encoder + ?Sized,
1742 &'a BusReadBarRequest: ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>,
1743 {
1744 #[inline]
1745 fn encode_option(
1746 this: ::core::option::Option<Self>,
1747 encoder: &mut ___E,
1748 out: &mut ::core::mem::MaybeUninit<
1749 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarRequest>,
1750 >,
1751 _: (),
1752 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1753 if let Some(inner) = this {
1754 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1755 ::fidl_next::wire::Box::encode_present(out);
1756 } else {
1757 ::fidl_next::wire::Box::encode_absent(out);
1758 }
1759
1760 Ok(())
1761 }
1762 }
1763
1764 impl ::fidl_next::FromWire<crate::wire::BusReadBarRequest> for BusReadBarRequest {
1765 #[inline]
1766 fn from_wire(wire: crate::wire::BusReadBarRequest) -> Self {
1767 Self {
1768 device: ::fidl_next::FromWire::from_wire(wire.device),
1769
1770 bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id),
1771
1772 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1773
1774 size: ::fidl_next::FromWire::from_wire(wire.size),
1775 }
1776 }
1777 }
1778
1779 impl ::fidl_next::FromWireRef<crate::wire::BusReadBarRequest> for BusReadBarRequest {
1780 #[inline]
1781 fn from_wire_ref(wire: &crate::wire::BusReadBarRequest) -> Self {
1782 Self {
1783 device: ::fidl_next::FromWireRef::from_wire_ref(&wire.device),
1784
1785 bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id),
1786
1787 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1788
1789 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
1790 }
1791 }
1792 }
1793
1794 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1795 pub struct BusReadBarResponse {
1796 pub buffer: ::std::vec::Vec<u8>,
1797 }
1798
1799 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
1800 for BusReadBarResponse
1801 where
1802 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1803 ___E: ::fidl_next::Encoder,
1804 {
1805 #[inline]
1806 fn encode(
1807 self,
1808 encoder_: &mut ___E,
1809 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
1810 _: (),
1811 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1812 ::fidl_next::munge! {
1813 let crate::wire::BusReadBarResponse {
1814 buffer,
1815
1816 } = out_;
1817 }
1818
1819 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
1820
1821 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
1822 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1823
1824 Ok(())
1825 }
1826 }
1827
1828 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
1829 for &'a BusReadBarResponse
1830 where
1831 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1832 ___E: ::fidl_next::Encoder,
1833 {
1834 #[inline]
1835 fn encode(
1836 self,
1837 encoder_: &mut ___E,
1838 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
1839 _: (),
1840 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1841 ::fidl_next::munge! {
1842 let crate::wire::BusReadBarResponse {
1843 buffer,
1844
1845 } = out_;
1846 }
1847
1848 ::fidl_next::Encode::encode(&self.buffer, encoder_, buffer, (4294967295, ()))?;
1849
1850 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
1851 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1852
1853 Ok(())
1854 }
1855 }
1856
1857 unsafe impl<___E>
1858 ::fidl_next::EncodeOption<
1859 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1860 ___E,
1861 > for BusReadBarResponse
1862 where
1863 ___E: ::fidl_next::Encoder + ?Sized,
1864 BusReadBarResponse: ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>,
1865 {
1866 #[inline]
1867 fn encode_option(
1868 this: ::core::option::Option<Self>,
1869 encoder: &mut ___E,
1870 out: &mut ::core::mem::MaybeUninit<
1871 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1872 >,
1873 _: (),
1874 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1875 if let Some(inner) = this {
1876 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1877 ::fidl_next::wire::Box::encode_present(out);
1878 } else {
1879 ::fidl_next::wire::Box::encode_absent(out);
1880 }
1881
1882 Ok(())
1883 }
1884 }
1885
1886 unsafe impl<'a, ___E>
1887 ::fidl_next::EncodeOption<
1888 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1889 ___E,
1890 > for &'a BusReadBarResponse
1891 where
1892 ___E: ::fidl_next::Encoder + ?Sized,
1893 &'a BusReadBarResponse: ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>,
1894 {
1895 #[inline]
1896 fn encode_option(
1897 this: ::core::option::Option<Self>,
1898 encoder: &mut ___E,
1899 out: &mut ::core::mem::MaybeUninit<
1900 ::fidl_next::wire::Box<'static, crate::wire::BusReadBarResponse<'static>>,
1901 >,
1902 _: (),
1903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1904 if let Some(inner) = this {
1905 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1906 ::fidl_next::wire::Box::encode_present(out);
1907 } else {
1908 ::fidl_next::wire::Box::encode_absent(out);
1909 }
1910
1911 Ok(())
1912 }
1913 }
1914
1915 impl<'de> ::fidl_next::FromWire<crate::wire::BusReadBarResponse<'de>> for BusReadBarResponse {
1916 #[inline]
1917 fn from_wire(wire: crate::wire::BusReadBarResponse<'de>) -> Self {
1918 Self { buffer: ::fidl_next::FromWire::from_wire(wire.buffer) }
1919 }
1920 }
1921
1922 impl<'de> ::fidl_next::FromWireRef<crate::wire::BusReadBarResponse<'de>> for BusReadBarResponse {
1923 #[inline]
1924 fn from_wire_ref(wire: &crate::wire::BusReadBarResponse<'de>) -> Self {
1925 Self { buffer: ::fidl_next::FromWireRef::from_wire_ref(&wire.buffer) }
1926 }
1927 }
1928
1929 #[doc = " PCI Capability ID.\n PCI Local Bus Specification v3, appendex H.\n"]
1930 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1931 #[repr(u8)]
1932 pub enum CapabilityId {
1933 Null = 0,
1934 PciPwrMgmt = 1,
1935 Agp = 2,
1936 VitalProductData = 3,
1937 SlotIdentification = 4,
1938 Msi = 5,
1939 CompactPciHotswap = 6,
1940 Pcix = 7,
1941 Hypertransport = 8,
1942 Vendor = 9,
1943 DebugPort = 10,
1944 CompactPciCrc = 11,
1945 PciHotPlug = 12,
1946 PciBridgeSubsystemVid = 13,
1947 Agp8X = 14,
1948 SecureDevice = 15,
1949 PciExpress = 16,
1950 Msix = 17,
1951 SataDataNdxCfg = 18,
1952 AdvancedFeatures = 19,
1953 EnhancedAllocation = 20,
1954 FlatteningPortalBridge = 21,
1955 UnknownOrdinal_(u8) = 22,
1956 }
1957 impl ::std::convert::From<u8> for CapabilityId {
1958 fn from(value: u8) -> Self {
1959 match value {
1960 0 => Self::Null,
1961 1 => Self::PciPwrMgmt,
1962 2 => Self::Agp,
1963 3 => Self::VitalProductData,
1964 4 => Self::SlotIdentification,
1965 5 => Self::Msi,
1966 6 => Self::CompactPciHotswap,
1967 7 => Self::Pcix,
1968 8 => Self::Hypertransport,
1969 9 => Self::Vendor,
1970 10 => Self::DebugPort,
1971 11 => Self::CompactPciCrc,
1972 12 => Self::PciHotPlug,
1973 13 => Self::PciBridgeSubsystemVid,
1974 14 => Self::Agp8X,
1975 15 => Self::SecureDevice,
1976 16 => Self::PciExpress,
1977 17 => Self::Msix,
1978 18 => Self::SataDataNdxCfg,
1979 19 => Self::AdvancedFeatures,
1980 20 => Self::EnhancedAllocation,
1981 21 => Self::FlatteningPortalBridge,
1982
1983 _ => Self::UnknownOrdinal_(value),
1984 }
1985 }
1986 }
1987
1988 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for CapabilityId
1989 where
1990 ___E: ?Sized,
1991 {
1992 #[inline]
1993 fn encode(
1994 self,
1995 encoder: &mut ___E,
1996 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
1997 _: (),
1998 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1999 ::fidl_next::Encode::encode(&self, encoder, out, ())
2000 }
2001 }
2002
2003 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for &'a CapabilityId
2004 where
2005 ___E: ?Sized,
2006 {
2007 #[inline]
2008 fn encode(
2009 self,
2010 encoder: &mut ___E,
2011 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
2012 _: (),
2013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2014 ::fidl_next::munge!(let crate::wire::CapabilityId { value } = out);
2015 let _ = value.write(u8::from(match *self {
2016 CapabilityId::Null => 0,
2017
2018 CapabilityId::PciPwrMgmt => 1,
2019
2020 CapabilityId::Agp => 2,
2021
2022 CapabilityId::VitalProductData => 3,
2023
2024 CapabilityId::SlotIdentification => 4,
2025
2026 CapabilityId::Msi => 5,
2027
2028 CapabilityId::CompactPciHotswap => 6,
2029
2030 CapabilityId::Pcix => 7,
2031
2032 CapabilityId::Hypertransport => 8,
2033
2034 CapabilityId::Vendor => 9,
2035
2036 CapabilityId::DebugPort => 10,
2037
2038 CapabilityId::CompactPciCrc => 11,
2039
2040 CapabilityId::PciHotPlug => 12,
2041
2042 CapabilityId::PciBridgeSubsystemVid => 13,
2043
2044 CapabilityId::Agp8X => 14,
2045
2046 CapabilityId::SecureDevice => 15,
2047
2048 CapabilityId::PciExpress => 16,
2049
2050 CapabilityId::Msix => 17,
2051
2052 CapabilityId::SataDataNdxCfg => 18,
2053
2054 CapabilityId::AdvancedFeatures => 19,
2055
2056 CapabilityId::EnhancedAllocation => 20,
2057
2058 CapabilityId::FlatteningPortalBridge => 21,
2059
2060 CapabilityId::UnknownOrdinal_(value) => value,
2061 }));
2062
2063 Ok(())
2064 }
2065 }
2066
2067 impl ::core::convert::From<crate::wire::CapabilityId> for CapabilityId {
2068 fn from(wire: crate::wire::CapabilityId) -> Self {
2069 match u8::from(wire.value) {
2070 0 => Self::Null,
2071
2072 1 => Self::PciPwrMgmt,
2073
2074 2 => Self::Agp,
2075
2076 3 => Self::VitalProductData,
2077
2078 4 => Self::SlotIdentification,
2079
2080 5 => Self::Msi,
2081
2082 6 => Self::CompactPciHotswap,
2083
2084 7 => Self::Pcix,
2085
2086 8 => Self::Hypertransport,
2087
2088 9 => Self::Vendor,
2089
2090 10 => Self::DebugPort,
2091
2092 11 => Self::CompactPciCrc,
2093
2094 12 => Self::PciHotPlug,
2095
2096 13 => Self::PciBridgeSubsystemVid,
2097
2098 14 => Self::Agp8X,
2099
2100 15 => Self::SecureDevice,
2101
2102 16 => Self::PciExpress,
2103
2104 17 => Self::Msix,
2105
2106 18 => Self::SataDataNdxCfg,
2107
2108 19 => Self::AdvancedFeatures,
2109
2110 20 => Self::EnhancedAllocation,
2111
2112 21 => Self::FlatteningPortalBridge,
2113
2114 value => Self::UnknownOrdinal_(value),
2115 }
2116 }
2117 }
2118
2119 impl ::fidl_next::FromWire<crate::wire::CapabilityId> for CapabilityId {
2120 #[inline]
2121 fn from_wire(wire: crate::wire::CapabilityId) -> Self {
2122 Self::from(wire)
2123 }
2124 }
2125
2126 impl ::fidl_next::FromWireRef<crate::wire::CapabilityId> for CapabilityId {
2127 #[inline]
2128 fn from_wire_ref(wire: &crate::wire::CapabilityId) -> Self {
2129 Self::from(*wire)
2130 }
2131 }
2132
2133 ::fidl_next::bitflags::bitflags! {
2134 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Command: u16 {
2135 const IO_EN = 1;
2136 const MEM_EN = 2;
2137 const BUS_MASTER_EN = 4;
2138 const SPECIAL_EN = 8;
2139 const MEM_WR_INV_EN = 16;
2140 const PAL_SNOOP_EN = 32;
2141 const PERR_RESP_EN = 64;
2142 const AD_STEP_EN = 128;
2143 const SERR_EN = 256;
2144 const FAST_B2_B_EN = 512;
2145 const _ = !0;
2146 }
2147 }
2148
2149 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Command, ___E> for Command
2150 where
2151 ___E: ?Sized,
2152 {
2153 #[inline]
2154 fn encode(
2155 self,
2156 encoder: &mut ___E,
2157 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
2158 _: (),
2159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2160 ::fidl_next::Encode::encode(&self, encoder, out, ())
2161 }
2162 }
2163
2164 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Command, ___E> for &'a Command
2165 where
2166 ___E: ?Sized,
2167 {
2168 #[inline]
2169 fn encode(
2170 self,
2171 _: &mut ___E,
2172 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
2173 _: (),
2174 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2175 ::fidl_next::munge!(let crate::wire::Command { value } = out);
2176
2177 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
2178 Ok(())
2179 }
2180 }
2181
2182 impl ::core::convert::From<crate::wire::Command> for Command {
2183 fn from(wire: crate::wire::Command) -> Self {
2184 Self::from_bits_retain(u16::from(wire.value))
2185 }
2186 }
2187
2188 impl ::fidl_next::FromWire<crate::wire::Command> for Command {
2189 #[inline]
2190 fn from_wire(wire: crate::wire::Command) -> Self {
2191 Self::from(wire)
2192 }
2193 }
2194
2195 impl ::fidl_next::FromWireRef<crate::wire::Command> for Command {
2196 #[inline]
2197 fn from_wire_ref(wire: &crate::wire::Command) -> Self {
2198 Self::from(*wire)
2199 }
2200 }
2201
2202 #[doc = " PCI Configuration Header registers.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
2203 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2204 #[repr(u16)]
2205 pub enum Config {
2206 VendorId = 0,
2207 DeviceId = 2,
2208 Command = 4,
2209 Status = 6,
2210 RevisionId = 8,
2211 ClassCodeIntr = 9,
2212 ClassCodeSub = 10,
2213 ClassCodeBase = 11,
2214 CacheLineSize = 12,
2215 LatencyTimer = 13,
2216 HeaderType = 14,
2217 Bist = 15,
2218 BaseAddresses = 16,
2219 CardbusCisPtr = 40,
2220 SubsystemVendorId = 44,
2221 SubsystemId = 46,
2222 ExpRomAddress = 48,
2223 CapabilitiesPtr = 52,
2224 InterruptLine = 60,
2225 InterruptPin = 61,
2226 MinGrant = 62,
2227 MaxLatency = 63,
2228 UnknownOrdinal_(u16) = 64,
2229 }
2230 impl ::std::convert::From<u16> for Config {
2231 fn from(value: u16) -> Self {
2232 match value {
2233 0 => Self::VendorId,
2234 2 => Self::DeviceId,
2235 4 => Self::Command,
2236 6 => Self::Status,
2237 8 => Self::RevisionId,
2238 9 => Self::ClassCodeIntr,
2239 10 => Self::ClassCodeSub,
2240 11 => Self::ClassCodeBase,
2241 12 => Self::CacheLineSize,
2242 13 => Self::LatencyTimer,
2243 14 => Self::HeaderType,
2244 15 => Self::Bist,
2245 16 => Self::BaseAddresses,
2246 40 => Self::CardbusCisPtr,
2247 44 => Self::SubsystemVendorId,
2248 46 => Self::SubsystemId,
2249 48 => Self::ExpRomAddress,
2250 52 => Self::CapabilitiesPtr,
2251 60 => Self::InterruptLine,
2252 61 => Self::InterruptPin,
2253 62 => Self::MinGrant,
2254 63 => Self::MaxLatency,
2255
2256 _ => Self::UnknownOrdinal_(value),
2257 }
2258 }
2259 }
2260
2261 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Config, ___E> for Config
2262 where
2263 ___E: ?Sized,
2264 {
2265 #[inline]
2266 fn encode(
2267 self,
2268 encoder: &mut ___E,
2269 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
2270 _: (),
2271 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2272 ::fidl_next::Encode::encode(&self, encoder, out, ())
2273 }
2274 }
2275
2276 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Config, ___E> for &'a Config
2277 where
2278 ___E: ?Sized,
2279 {
2280 #[inline]
2281 fn encode(
2282 self,
2283 encoder: &mut ___E,
2284 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
2285 _: (),
2286 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2287 ::fidl_next::munge!(let crate::wire::Config { value } = out);
2288 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
2289 Config::VendorId => 0,
2290
2291 Config::DeviceId => 2,
2292
2293 Config::Command => 4,
2294
2295 Config::Status => 6,
2296
2297 Config::RevisionId => 8,
2298
2299 Config::ClassCodeIntr => 9,
2300
2301 Config::ClassCodeSub => 10,
2302
2303 Config::ClassCodeBase => 11,
2304
2305 Config::CacheLineSize => 12,
2306
2307 Config::LatencyTimer => 13,
2308
2309 Config::HeaderType => 14,
2310
2311 Config::Bist => 15,
2312
2313 Config::BaseAddresses => 16,
2314
2315 Config::CardbusCisPtr => 40,
2316
2317 Config::SubsystemVendorId => 44,
2318
2319 Config::SubsystemId => 46,
2320
2321 Config::ExpRomAddress => 48,
2322
2323 Config::CapabilitiesPtr => 52,
2324
2325 Config::InterruptLine => 60,
2326
2327 Config::InterruptPin => 61,
2328
2329 Config::MinGrant => 62,
2330
2331 Config::MaxLatency => 63,
2332
2333 Config::UnknownOrdinal_(value) => value,
2334 }));
2335
2336 Ok(())
2337 }
2338 }
2339
2340 impl ::core::convert::From<crate::wire::Config> for Config {
2341 fn from(wire: crate::wire::Config) -> Self {
2342 match u16::from(wire.value) {
2343 0 => Self::VendorId,
2344
2345 2 => Self::DeviceId,
2346
2347 4 => Self::Command,
2348
2349 6 => Self::Status,
2350
2351 8 => Self::RevisionId,
2352
2353 9 => Self::ClassCodeIntr,
2354
2355 10 => Self::ClassCodeSub,
2356
2357 11 => Self::ClassCodeBase,
2358
2359 12 => Self::CacheLineSize,
2360
2361 13 => Self::LatencyTimer,
2362
2363 14 => Self::HeaderType,
2364
2365 15 => Self::Bist,
2366
2367 16 => Self::BaseAddresses,
2368
2369 40 => Self::CardbusCisPtr,
2370
2371 44 => Self::SubsystemVendorId,
2372
2373 46 => Self::SubsystemId,
2374
2375 48 => Self::ExpRomAddress,
2376
2377 52 => Self::CapabilitiesPtr,
2378
2379 60 => Self::InterruptLine,
2380
2381 61 => Self::InterruptPin,
2382
2383 62 => Self::MinGrant,
2384
2385 63 => Self::MaxLatency,
2386
2387 value => Self::UnknownOrdinal_(value),
2388 }
2389 }
2390 }
2391
2392 impl ::fidl_next::FromWire<crate::wire::Config> for Config {
2393 #[inline]
2394 fn from_wire(wire: crate::wire::Config) -> Self {
2395 Self::from(wire)
2396 }
2397 }
2398
2399 impl ::fidl_next::FromWireRef<crate::wire::Config> for Config {
2400 #[inline]
2401 fn from_wire_ref(wire: &crate::wire::Config) -> Self {
2402 Self::from(*wire)
2403 }
2404 }
2405
2406 #[doc = " An offset from the beginning of a device\'s PCI configuration space. [0, 0x100) is valid.\n"]
2407 pub type ConfigOffset = u8;
2408
2409 pub type Padding = ();
2410
2411 #[doc = " Device specific information from a device\'s configuration header.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
2412 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2413 #[repr(C)]
2414 pub struct DeviceInfo {
2415 pub vendor_id: u16,
2416
2417 pub device_id: u16,
2418
2419 pub base_class: u8,
2420
2421 pub sub_class: u8,
2422
2423 pub program_interface: u8,
2424
2425 pub revision_id: u8,
2426
2427 pub bus_id: u8,
2428
2429 pub dev_id: u8,
2430
2431 pub func_id: u8,
2432
2433 pub padding: crate::natural::Padding,
2434 }
2435
2436 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for DeviceInfo
2437 where
2438 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2439 {
2440 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DeviceInfo> = unsafe {
2441 ::fidl_next::CopyOptimization::enable_if(
2442 true
2443
2444 && <
2445 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2446 >::COPY_OPTIMIZATION.is_enabled()
2447
2448 && <
2449 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2450 >::COPY_OPTIMIZATION.is_enabled()
2451
2452 && <
2453 u8 as ::fidl_next::Encode<u8, ___E>
2454 >::COPY_OPTIMIZATION.is_enabled()
2455
2456 && <
2457 u8 as ::fidl_next::Encode<u8, ___E>
2458 >::COPY_OPTIMIZATION.is_enabled()
2459
2460 && <
2461 u8 as ::fidl_next::Encode<u8, ___E>
2462 >::COPY_OPTIMIZATION.is_enabled()
2463
2464 && <
2465 u8 as ::fidl_next::Encode<u8, ___E>
2466 >::COPY_OPTIMIZATION.is_enabled()
2467
2468 && <
2469 u8 as ::fidl_next::Encode<u8, ___E>
2470 >::COPY_OPTIMIZATION.is_enabled()
2471
2472 && <
2473 u8 as ::fidl_next::Encode<u8, ___E>
2474 >::COPY_OPTIMIZATION.is_enabled()
2475
2476 && <
2477 u8 as ::fidl_next::Encode<u8, ___E>
2478 >::COPY_OPTIMIZATION.is_enabled()
2479
2480 && <
2481 crate::natural::Padding as ::fidl_next::Encode<crate::wire::Padding, ___E>
2482 >::COPY_OPTIMIZATION.is_enabled()
2483
2484 )
2485 };
2486
2487 #[inline]
2488 fn encode(
2489 self,
2490 encoder_: &mut ___E,
2491 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2492 _: (),
2493 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2494 ::fidl_next::munge! {
2495 let crate::wire::DeviceInfo {
2496 vendor_id,
2497 device_id,
2498 base_class,
2499 sub_class,
2500 program_interface,
2501 revision_id,
2502 bus_id,
2503 dev_id,
2504 func_id,
2505 padding,
2506
2507 } = out_;
2508 }
2509
2510 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
2511
2512 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2513
2514 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
2515
2516 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2517
2518 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
2519
2520 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2521
2522 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
2523
2524 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2525
2526 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
2527
2528 let mut _field =
2529 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2530
2531 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
2532
2533 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2534
2535 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
2536
2537 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2538
2539 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
2540
2541 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2542
2543 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
2544
2545 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2546
2547 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
2548
2549 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2550
2551 Ok(())
2552 }
2553 }
2554
2555 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for &'a DeviceInfo
2556 where
2557 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2558 {
2559 #[inline]
2560 fn encode(
2561 self,
2562 encoder_: &mut ___E,
2563 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2564 _: (),
2565 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2566 ::fidl_next::munge! {
2567 let crate::wire::DeviceInfo {
2568 vendor_id,
2569 device_id,
2570 base_class,
2571 sub_class,
2572 program_interface,
2573 revision_id,
2574 bus_id,
2575 dev_id,
2576 func_id,
2577 padding,
2578
2579 } = out_;
2580 }
2581
2582 ::fidl_next::Encode::encode(&self.vendor_id, encoder_, vendor_id, ())?;
2583
2584 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2585
2586 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
2587
2588 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2589
2590 ::fidl_next::Encode::encode(&self.base_class, encoder_, base_class, ())?;
2591
2592 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2593
2594 ::fidl_next::Encode::encode(&self.sub_class, encoder_, sub_class, ())?;
2595
2596 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2597
2598 ::fidl_next::Encode::encode(&self.program_interface, encoder_, program_interface, ())?;
2599
2600 let mut _field =
2601 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2602
2603 ::fidl_next::Encode::encode(&self.revision_id, encoder_, revision_id, ())?;
2604
2605 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2606
2607 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
2608
2609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2610
2611 ::fidl_next::Encode::encode(&self.dev_id, encoder_, dev_id, ())?;
2612
2613 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2614
2615 ::fidl_next::Encode::encode(&self.func_id, encoder_, func_id, ())?;
2616
2617 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2618
2619 ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
2620
2621 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2622
2623 Ok(())
2624 }
2625 }
2626
2627 unsafe impl<___E>
2628 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2629 for DeviceInfo
2630 where
2631 ___E: ::fidl_next::Encoder + ?Sized,
2632 DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2633 {
2634 #[inline]
2635 fn encode_option(
2636 this: ::core::option::Option<Self>,
2637 encoder: &mut ___E,
2638 out: &mut ::core::mem::MaybeUninit<
2639 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2640 >,
2641 _: (),
2642 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2643 if let Some(inner) = this {
2644 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2645 ::fidl_next::wire::Box::encode_present(out);
2646 } else {
2647 ::fidl_next::wire::Box::encode_absent(out);
2648 }
2649
2650 Ok(())
2651 }
2652 }
2653
2654 unsafe impl<'a, ___E>
2655 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2656 for &'a DeviceInfo
2657 where
2658 ___E: ::fidl_next::Encoder + ?Sized,
2659 &'a DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2660 {
2661 #[inline]
2662 fn encode_option(
2663 this: ::core::option::Option<Self>,
2664 encoder: &mut ___E,
2665 out: &mut ::core::mem::MaybeUninit<
2666 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2667 >,
2668 _: (),
2669 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2670 if let Some(inner) = this {
2671 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2672 ::fidl_next::wire::Box::encode_present(out);
2673 } else {
2674 ::fidl_next::wire::Box::encode_absent(out);
2675 }
2676
2677 Ok(())
2678 }
2679 }
2680
2681 impl ::fidl_next::FromWire<crate::wire::DeviceInfo> for DeviceInfo {
2682 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DeviceInfo, Self> = unsafe {
2683 ::fidl_next::CopyOptimization::enable_if(
2684 true
2685
2686 && <
2687 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2688 >::COPY_OPTIMIZATION.is_enabled()
2689
2690 && <
2691 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2692 >::COPY_OPTIMIZATION.is_enabled()
2693
2694 && <
2695 u8 as ::fidl_next::FromWire<u8>
2696 >::COPY_OPTIMIZATION.is_enabled()
2697
2698 && <
2699 u8 as ::fidl_next::FromWire<u8>
2700 >::COPY_OPTIMIZATION.is_enabled()
2701
2702 && <
2703 u8 as ::fidl_next::FromWire<u8>
2704 >::COPY_OPTIMIZATION.is_enabled()
2705
2706 && <
2707 u8 as ::fidl_next::FromWire<u8>
2708 >::COPY_OPTIMIZATION.is_enabled()
2709
2710 && <
2711 u8 as ::fidl_next::FromWire<u8>
2712 >::COPY_OPTIMIZATION.is_enabled()
2713
2714 && <
2715 u8 as ::fidl_next::FromWire<u8>
2716 >::COPY_OPTIMIZATION.is_enabled()
2717
2718 && <
2719 u8 as ::fidl_next::FromWire<u8>
2720 >::COPY_OPTIMIZATION.is_enabled()
2721
2722 && <
2723 crate::natural::Padding as ::fidl_next::FromWire<crate::wire::Padding>
2724 >::COPY_OPTIMIZATION.is_enabled()
2725
2726 )
2727 };
2728
2729 #[inline]
2730 fn from_wire(wire: crate::wire::DeviceInfo) -> Self {
2731 Self {
2732 vendor_id: ::fidl_next::FromWire::from_wire(wire.vendor_id),
2733
2734 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
2735
2736 base_class: ::fidl_next::FromWire::from_wire(wire.base_class),
2737
2738 sub_class: ::fidl_next::FromWire::from_wire(wire.sub_class),
2739
2740 program_interface: ::fidl_next::FromWire::from_wire(wire.program_interface),
2741
2742 revision_id: ::fidl_next::FromWire::from_wire(wire.revision_id),
2743
2744 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
2745
2746 dev_id: ::fidl_next::FromWire::from_wire(wire.dev_id),
2747
2748 func_id: ::fidl_next::FromWire::from_wire(wire.func_id),
2749
2750 padding: ::fidl_next::FromWire::from_wire(wire.padding),
2751 }
2752 }
2753 }
2754
2755 impl ::fidl_next::FromWireRef<crate::wire::DeviceInfo> for DeviceInfo {
2756 #[inline]
2757 fn from_wire_ref(wire: &crate::wire::DeviceInfo) -> Self {
2758 Self {
2759 vendor_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.vendor_id),
2760
2761 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
2762
2763 base_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_class),
2764
2765 sub_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.sub_class),
2766
2767 program_interface: ::fidl_next::FromWireRef::from_wire_ref(&wire.program_interface),
2768
2769 revision_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.revision_id),
2770
2771 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
2772
2773 dev_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dev_id),
2774
2775 func_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.func_id),
2776
2777 padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
2778 }
2779 }
2780 }
2781
2782 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2783 #[repr(C)]
2784 pub struct DeviceGetDeviceInfoResponse {
2785 pub info: crate::natural::DeviceInfo,
2786 }
2787
2788 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
2789 for DeviceGetDeviceInfoResponse
2790 where
2791 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2792 {
2793 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2794 Self,
2795 crate::wire::DeviceGetDeviceInfoResponse,
2796 > = unsafe {
2797 ::fidl_next::CopyOptimization::enable_if(
2798 true && <crate::natural::DeviceInfo as ::fidl_next::Encode<
2799 crate::wire::DeviceInfo,
2800 ___E,
2801 >>::COPY_OPTIMIZATION
2802 .is_enabled(),
2803 )
2804 };
2805
2806 #[inline]
2807 fn encode(
2808 self,
2809 encoder_: &mut ___E,
2810 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
2811 _: (),
2812 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2813 ::fidl_next::munge! {
2814 let crate::wire::DeviceGetDeviceInfoResponse {
2815 info,
2816
2817 } = out_;
2818 }
2819
2820 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
2821
2822 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
2823
2824 Ok(())
2825 }
2826 }
2827
2828 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
2829 for &'a DeviceGetDeviceInfoResponse
2830 where
2831 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2832 {
2833 #[inline]
2834 fn encode(
2835 self,
2836 encoder_: &mut ___E,
2837 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
2838 _: (),
2839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2840 ::fidl_next::munge! {
2841 let crate::wire::DeviceGetDeviceInfoResponse {
2842 info,
2843
2844 } = out_;
2845 }
2846
2847 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
2848
2849 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
2850
2851 Ok(())
2852 }
2853 }
2854
2855 unsafe impl<___E>
2856 ::fidl_next::EncodeOption<
2857 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2858 ___E,
2859 > for DeviceGetDeviceInfoResponse
2860 where
2861 ___E: ::fidl_next::Encoder + ?Sized,
2862 DeviceGetDeviceInfoResponse:
2863 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
2864 {
2865 #[inline]
2866 fn encode_option(
2867 this: ::core::option::Option<Self>,
2868 encoder: &mut ___E,
2869 out: &mut ::core::mem::MaybeUninit<
2870 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2871 >,
2872 _: (),
2873 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2874 if let Some(inner) = this {
2875 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2876 ::fidl_next::wire::Box::encode_present(out);
2877 } else {
2878 ::fidl_next::wire::Box::encode_absent(out);
2879 }
2880
2881 Ok(())
2882 }
2883 }
2884
2885 unsafe impl<'a, ___E>
2886 ::fidl_next::EncodeOption<
2887 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2888 ___E,
2889 > for &'a DeviceGetDeviceInfoResponse
2890 where
2891 ___E: ::fidl_next::Encoder + ?Sized,
2892 &'a DeviceGetDeviceInfoResponse:
2893 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
2894 {
2895 #[inline]
2896 fn encode_option(
2897 this: ::core::option::Option<Self>,
2898 encoder: &mut ___E,
2899 out: &mut ::core::mem::MaybeUninit<
2900 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
2901 >,
2902 _: (),
2903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2904 if let Some(inner) = this {
2905 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2906 ::fidl_next::wire::Box::encode_present(out);
2907 } else {
2908 ::fidl_next::wire::Box::encode_absent(out);
2909 }
2910
2911 Ok(())
2912 }
2913 }
2914
2915 impl ::fidl_next::FromWire<crate::wire::DeviceGetDeviceInfoResponse>
2916 for DeviceGetDeviceInfoResponse
2917 {
2918 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2919 crate::wire::DeviceGetDeviceInfoResponse,
2920 Self,
2921 > = unsafe {
2922 ::fidl_next::CopyOptimization::enable_if(
2923 true && <crate::natural::DeviceInfo as ::fidl_next::FromWire<
2924 crate::wire::DeviceInfo,
2925 >>::COPY_OPTIMIZATION
2926 .is_enabled(),
2927 )
2928 };
2929
2930 #[inline]
2931 fn from_wire(wire: crate::wire::DeviceGetDeviceInfoResponse) -> Self {
2932 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
2933 }
2934 }
2935
2936 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetDeviceInfoResponse>
2937 for DeviceGetDeviceInfoResponse
2938 {
2939 #[inline]
2940 fn from_wire_ref(wire: &crate::wire::DeviceGetDeviceInfoResponse) -> Self {
2941 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
2942 }
2943 }
2944
2945 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2946 #[repr(C)]
2947 pub struct DeviceGetBarRequest {
2948 pub bar_id: u32,
2949 }
2950
2951 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
2952 for DeviceGetBarRequest
2953 where
2954 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2955 {
2956 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2957 Self,
2958 crate::wire::DeviceGetBarRequest,
2959 > = unsafe {
2960 ::fidl_next::CopyOptimization::enable_if(
2961 true
2962
2963 && <
2964 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
2965 >::COPY_OPTIMIZATION.is_enabled()
2966
2967 )
2968 };
2969
2970 #[inline]
2971 fn encode(
2972 self,
2973 encoder_: &mut ___E,
2974 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
2975 _: (),
2976 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2977 ::fidl_next::munge! {
2978 let crate::wire::DeviceGetBarRequest {
2979 bar_id,
2980
2981 } = out_;
2982 }
2983
2984 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
2985
2986 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
2987
2988 Ok(())
2989 }
2990 }
2991
2992 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
2993 for &'a DeviceGetBarRequest
2994 where
2995 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2996 {
2997 #[inline]
2998 fn encode(
2999 self,
3000 encoder_: &mut ___E,
3001 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
3002 _: (),
3003 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3004 ::fidl_next::munge! {
3005 let crate::wire::DeviceGetBarRequest {
3006 bar_id,
3007
3008 } = out_;
3009 }
3010
3011 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
3012
3013 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
3014
3015 Ok(())
3016 }
3017 }
3018
3019 unsafe impl<___E>
3020 ::fidl_next::EncodeOption<
3021 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3022 ___E,
3023 > for DeviceGetBarRequest
3024 where
3025 ___E: ::fidl_next::Encoder + ?Sized,
3026 DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3027 {
3028 #[inline]
3029 fn encode_option(
3030 this: ::core::option::Option<Self>,
3031 encoder: &mut ___E,
3032 out: &mut ::core::mem::MaybeUninit<
3033 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3034 >,
3035 _: (),
3036 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3037 if let Some(inner) = this {
3038 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3039 ::fidl_next::wire::Box::encode_present(out);
3040 } else {
3041 ::fidl_next::wire::Box::encode_absent(out);
3042 }
3043
3044 Ok(())
3045 }
3046 }
3047
3048 unsafe impl<'a, ___E>
3049 ::fidl_next::EncodeOption<
3050 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3051 ___E,
3052 > for &'a DeviceGetBarRequest
3053 where
3054 ___E: ::fidl_next::Encoder + ?Sized,
3055 &'a DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3056 {
3057 #[inline]
3058 fn encode_option(
3059 this: ::core::option::Option<Self>,
3060 encoder: &mut ___E,
3061 out: &mut ::core::mem::MaybeUninit<
3062 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3063 >,
3064 _: (),
3065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3066 if let Some(inner) = this {
3067 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3068 ::fidl_next::wire::Box::encode_present(out);
3069 } else {
3070 ::fidl_next::wire::Box::encode_absent(out);
3071 }
3072
3073 Ok(())
3074 }
3075 }
3076
3077 impl ::fidl_next::FromWire<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3078 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3079 crate::wire::DeviceGetBarRequest,
3080 Self,
3081 > = unsafe {
3082 ::fidl_next::CopyOptimization::enable_if(
3083 true
3084 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3085 .is_enabled(),
3086 )
3087 };
3088
3089 #[inline]
3090 fn from_wire(wire: crate::wire::DeviceGetBarRequest) -> Self {
3091 Self { bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id) }
3092 }
3093 }
3094
3095 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3096 #[inline]
3097 fn from_wire_ref(wire: &crate::wire::DeviceGetBarRequest) -> Self {
3098 Self { bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id) }
3099 }
3100 }
3101
3102 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3103 #[repr(C)]
3104 pub struct DeviceSetBusMasteringRequest {
3105 pub enabled: bool,
3106 }
3107
3108 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3109 for DeviceSetBusMasteringRequest
3110 where
3111 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3112 {
3113 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3114 Self,
3115 crate::wire::DeviceSetBusMasteringRequest,
3116 > = unsafe {
3117 ::fidl_next::CopyOptimization::enable_if(
3118 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
3119 )
3120 };
3121
3122 #[inline]
3123 fn encode(
3124 self,
3125 encoder_: &mut ___E,
3126 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3127 _: (),
3128 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3129 ::fidl_next::munge! {
3130 let crate::wire::DeviceSetBusMasteringRequest {
3131 enabled,
3132
3133 } = out_;
3134 }
3135
3136 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
3137
3138 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3139
3140 Ok(())
3141 }
3142 }
3143
3144 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3145 for &'a DeviceSetBusMasteringRequest
3146 where
3147 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3148 {
3149 #[inline]
3150 fn encode(
3151 self,
3152 encoder_: &mut ___E,
3153 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3154 _: (),
3155 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3156 ::fidl_next::munge! {
3157 let crate::wire::DeviceSetBusMasteringRequest {
3158 enabled,
3159
3160 } = out_;
3161 }
3162
3163 ::fidl_next::Encode::encode(&self.enabled, encoder_, enabled, ())?;
3164
3165 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3166
3167 Ok(())
3168 }
3169 }
3170
3171 unsafe impl<___E>
3172 ::fidl_next::EncodeOption<
3173 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3174 ___E,
3175 > for DeviceSetBusMasteringRequest
3176 where
3177 ___E: ::fidl_next::Encoder + ?Sized,
3178 DeviceSetBusMasteringRequest:
3179 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3180 {
3181 #[inline]
3182 fn encode_option(
3183 this: ::core::option::Option<Self>,
3184 encoder: &mut ___E,
3185 out: &mut ::core::mem::MaybeUninit<
3186 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3187 >,
3188 _: (),
3189 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3190 if let Some(inner) = this {
3191 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3192 ::fidl_next::wire::Box::encode_present(out);
3193 } else {
3194 ::fidl_next::wire::Box::encode_absent(out);
3195 }
3196
3197 Ok(())
3198 }
3199 }
3200
3201 unsafe impl<'a, ___E>
3202 ::fidl_next::EncodeOption<
3203 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3204 ___E,
3205 > for &'a DeviceSetBusMasteringRequest
3206 where
3207 ___E: ::fidl_next::Encoder + ?Sized,
3208 &'a DeviceSetBusMasteringRequest:
3209 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3210 {
3211 #[inline]
3212 fn encode_option(
3213 this: ::core::option::Option<Self>,
3214 encoder: &mut ___E,
3215 out: &mut ::core::mem::MaybeUninit<
3216 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3217 >,
3218 _: (),
3219 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3220 if let Some(inner) = this {
3221 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3222 ::fidl_next::wire::Box::encode_present(out);
3223 } else {
3224 ::fidl_next::wire::Box::encode_absent(out);
3225 }
3226
3227 Ok(())
3228 }
3229 }
3230
3231 impl ::fidl_next::FromWire<crate::wire::DeviceSetBusMasteringRequest>
3232 for DeviceSetBusMasteringRequest
3233 {
3234 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3235 crate::wire::DeviceSetBusMasteringRequest,
3236 Self,
3237 > = unsafe {
3238 ::fidl_next::CopyOptimization::enable_if(
3239 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
3240 )
3241 };
3242
3243 #[inline]
3244 fn from_wire(wire: crate::wire::DeviceSetBusMasteringRequest) -> Self {
3245 Self { enabled: ::fidl_next::FromWire::from_wire(wire.enabled) }
3246 }
3247 }
3248
3249 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetBusMasteringRequest>
3250 for DeviceSetBusMasteringRequest
3251 {
3252 #[inline]
3253 fn from_wire_ref(wire: &crate::wire::DeviceSetBusMasteringRequest) -> Self {
3254 Self { enabled: ::fidl_next::FromWireRef::from_wire_ref(&wire.enabled) }
3255 }
3256 }
3257
3258 pub type DeviceSetBusMasteringResponse = ();
3259
3260 pub type DeviceResetDeviceResponse = ();
3261
3262 pub type DeviceAckInterruptResponse = ();
3263
3264 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3265 #[repr(C)]
3266 pub struct DeviceMapInterruptRequest {
3267 pub which_irq: u32,
3268 }
3269
3270 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3271 for DeviceMapInterruptRequest
3272 where
3273 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3274 {
3275 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3276 Self,
3277 crate::wire::DeviceMapInterruptRequest,
3278 > = unsafe {
3279 ::fidl_next::CopyOptimization::enable_if(
3280 true
3281
3282 && <
3283 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3284 >::COPY_OPTIMIZATION.is_enabled()
3285
3286 )
3287 };
3288
3289 #[inline]
3290 fn encode(
3291 self,
3292 encoder_: &mut ___E,
3293 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3294 _: (),
3295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3296 ::fidl_next::munge! {
3297 let crate::wire::DeviceMapInterruptRequest {
3298 which_irq,
3299
3300 } = out_;
3301 }
3302
3303 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
3304
3305 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3306
3307 Ok(())
3308 }
3309 }
3310
3311 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3312 for &'a DeviceMapInterruptRequest
3313 where
3314 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3315 {
3316 #[inline]
3317 fn encode(
3318 self,
3319 encoder_: &mut ___E,
3320 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3321 _: (),
3322 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3323 ::fidl_next::munge! {
3324 let crate::wire::DeviceMapInterruptRequest {
3325 which_irq,
3326
3327 } = out_;
3328 }
3329
3330 ::fidl_next::Encode::encode(&self.which_irq, encoder_, which_irq, ())?;
3331
3332 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3333
3334 Ok(())
3335 }
3336 }
3337
3338 unsafe impl<___E>
3339 ::fidl_next::EncodeOption<
3340 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3341 ___E,
3342 > for DeviceMapInterruptRequest
3343 where
3344 ___E: ::fidl_next::Encoder + ?Sized,
3345 DeviceMapInterruptRequest:
3346 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3347 {
3348 #[inline]
3349 fn encode_option(
3350 this: ::core::option::Option<Self>,
3351 encoder: &mut ___E,
3352 out: &mut ::core::mem::MaybeUninit<
3353 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3354 >,
3355 _: (),
3356 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3357 if let Some(inner) = this {
3358 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3359 ::fidl_next::wire::Box::encode_present(out);
3360 } else {
3361 ::fidl_next::wire::Box::encode_absent(out);
3362 }
3363
3364 Ok(())
3365 }
3366 }
3367
3368 unsafe impl<'a, ___E>
3369 ::fidl_next::EncodeOption<
3370 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3371 ___E,
3372 > for &'a DeviceMapInterruptRequest
3373 where
3374 ___E: ::fidl_next::Encoder + ?Sized,
3375 &'a DeviceMapInterruptRequest:
3376 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3377 {
3378 #[inline]
3379 fn encode_option(
3380 this: ::core::option::Option<Self>,
3381 encoder: &mut ___E,
3382 out: &mut ::core::mem::MaybeUninit<
3383 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3384 >,
3385 _: (),
3386 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3387 if let Some(inner) = this {
3388 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3389 ::fidl_next::wire::Box::encode_present(out);
3390 } else {
3391 ::fidl_next::wire::Box::encode_absent(out);
3392 }
3393
3394 Ok(())
3395 }
3396 }
3397
3398 impl ::fidl_next::FromWire<crate::wire::DeviceMapInterruptRequest> for DeviceMapInterruptRequest {
3399 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3400 crate::wire::DeviceMapInterruptRequest,
3401 Self,
3402 > = unsafe {
3403 ::fidl_next::CopyOptimization::enable_if(
3404 true
3405 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3406 .is_enabled(),
3407 )
3408 };
3409
3410 #[inline]
3411 fn from_wire(wire: crate::wire::DeviceMapInterruptRequest) -> Self {
3412 Self { which_irq: ::fidl_next::FromWire::from_wire(wire.which_irq) }
3413 }
3414 }
3415
3416 impl ::fidl_next::FromWireRef<crate::wire::DeviceMapInterruptRequest>
3417 for DeviceMapInterruptRequest
3418 {
3419 #[inline]
3420 fn from_wire_ref(wire: &crate::wire::DeviceMapInterruptRequest) -> Self {
3421 Self { which_irq: ::fidl_next::FromWireRef::from_wire_ref(&wire.which_irq) }
3422 }
3423 }
3424
3425 #[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"]
3426 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3427 #[repr(C)]
3428 pub struct InterruptModes {
3429 pub has_legacy: bool,
3430
3431 pub msi_count: u8,
3432
3433 pub msix_count: u16,
3434 }
3435
3436 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for InterruptModes
3437 where
3438 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3439 {
3440 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InterruptModes> = unsafe {
3441 ::fidl_next::CopyOptimization::enable_if(
3442 true
3443
3444 && <
3445 bool as ::fidl_next::Encode<bool, ___E>
3446 >::COPY_OPTIMIZATION.is_enabled()
3447
3448 && <
3449 u8 as ::fidl_next::Encode<u8, ___E>
3450 >::COPY_OPTIMIZATION.is_enabled()
3451
3452 && <
3453 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
3454 >::COPY_OPTIMIZATION.is_enabled()
3455
3456 )
3457 };
3458
3459 #[inline]
3460 fn encode(
3461 self,
3462 encoder_: &mut ___E,
3463 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3464 _: (),
3465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3466 ::fidl_next::munge! {
3467 let crate::wire::InterruptModes {
3468 has_legacy,
3469 msi_count,
3470 msix_count,
3471
3472 } = out_;
3473 }
3474
3475 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
3476
3477 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3478
3479 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
3480
3481 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3482
3483 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
3484
3485 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3486
3487 Ok(())
3488 }
3489 }
3490
3491 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for &'a InterruptModes
3492 where
3493 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3494 {
3495 #[inline]
3496 fn encode(
3497 self,
3498 encoder_: &mut ___E,
3499 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3500 _: (),
3501 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3502 ::fidl_next::munge! {
3503 let crate::wire::InterruptModes {
3504 has_legacy,
3505 msi_count,
3506 msix_count,
3507
3508 } = out_;
3509 }
3510
3511 ::fidl_next::Encode::encode(&self.has_legacy, encoder_, has_legacy, ())?;
3512
3513 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3514
3515 ::fidl_next::Encode::encode(&self.msi_count, encoder_, msi_count, ())?;
3516
3517 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3518
3519 ::fidl_next::Encode::encode(&self.msix_count, encoder_, msix_count, ())?;
3520
3521 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3522
3523 Ok(())
3524 }
3525 }
3526
3527 unsafe impl<___E>
3528 ::fidl_next::EncodeOption<
3529 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3530 ___E,
3531 > for InterruptModes
3532 where
3533 ___E: ::fidl_next::Encoder + ?Sized,
3534 InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3535 {
3536 #[inline]
3537 fn encode_option(
3538 this: ::core::option::Option<Self>,
3539 encoder: &mut ___E,
3540 out: &mut ::core::mem::MaybeUninit<
3541 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3542 >,
3543 _: (),
3544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3545 if let Some(inner) = this {
3546 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3547 ::fidl_next::wire::Box::encode_present(out);
3548 } else {
3549 ::fidl_next::wire::Box::encode_absent(out);
3550 }
3551
3552 Ok(())
3553 }
3554 }
3555
3556 unsafe impl<'a, ___E>
3557 ::fidl_next::EncodeOption<
3558 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3559 ___E,
3560 > for &'a InterruptModes
3561 where
3562 ___E: ::fidl_next::Encoder + ?Sized,
3563 &'a InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3564 {
3565 #[inline]
3566 fn encode_option(
3567 this: ::core::option::Option<Self>,
3568 encoder: &mut ___E,
3569 out: &mut ::core::mem::MaybeUninit<
3570 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3571 >,
3572 _: (),
3573 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3574 if let Some(inner) = this {
3575 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3576 ::fidl_next::wire::Box::encode_present(out);
3577 } else {
3578 ::fidl_next::wire::Box::encode_absent(out);
3579 }
3580
3581 Ok(())
3582 }
3583 }
3584
3585 impl ::fidl_next::FromWire<crate::wire::InterruptModes> for InterruptModes {
3586 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InterruptModes, Self> = unsafe {
3587 ::fidl_next::CopyOptimization::enable_if(
3588 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled()
3589 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
3590 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
3591 .is_enabled(),
3592 )
3593 };
3594
3595 #[inline]
3596 fn from_wire(wire: crate::wire::InterruptModes) -> Self {
3597 Self {
3598 has_legacy: ::fidl_next::FromWire::from_wire(wire.has_legacy),
3599
3600 msi_count: ::fidl_next::FromWire::from_wire(wire.msi_count),
3601
3602 msix_count: ::fidl_next::FromWire::from_wire(wire.msix_count),
3603 }
3604 }
3605 }
3606
3607 impl ::fidl_next::FromWireRef<crate::wire::InterruptModes> for InterruptModes {
3608 #[inline]
3609 fn from_wire_ref(wire: &crate::wire::InterruptModes) -> Self {
3610 Self {
3611 has_legacy: ::fidl_next::FromWireRef::from_wire_ref(&wire.has_legacy),
3612
3613 msi_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msi_count),
3614
3615 msix_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msix_count),
3616 }
3617 }
3618 }
3619
3620 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3621 #[repr(C)]
3622 pub struct DeviceGetInterruptModesResponse {
3623 pub modes: crate::natural::InterruptModes,
3624 }
3625
3626 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3627 for DeviceGetInterruptModesResponse
3628 where
3629 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3630 {
3631 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3632 Self,
3633 crate::wire::DeviceGetInterruptModesResponse,
3634 > = unsafe {
3635 ::fidl_next::CopyOptimization::enable_if(
3636 true && <crate::natural::InterruptModes as ::fidl_next::Encode<
3637 crate::wire::InterruptModes,
3638 ___E,
3639 >>::COPY_OPTIMIZATION
3640 .is_enabled(),
3641 )
3642 };
3643
3644 #[inline]
3645 fn encode(
3646 self,
3647 encoder_: &mut ___E,
3648 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3649 _: (),
3650 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3651 ::fidl_next::munge! {
3652 let crate::wire::DeviceGetInterruptModesResponse {
3653 modes,
3654
3655 } = out_;
3656 }
3657
3658 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
3659
3660 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3661
3662 Ok(())
3663 }
3664 }
3665
3666 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3667 for &'a DeviceGetInterruptModesResponse
3668 where
3669 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3670 {
3671 #[inline]
3672 fn encode(
3673 self,
3674 encoder_: &mut ___E,
3675 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3676 _: (),
3677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3678 ::fidl_next::munge! {
3679 let crate::wire::DeviceGetInterruptModesResponse {
3680 modes,
3681
3682 } = out_;
3683 }
3684
3685 ::fidl_next::Encode::encode(&self.modes, encoder_, modes, ())?;
3686
3687 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3688
3689 Ok(())
3690 }
3691 }
3692
3693 unsafe impl<___E>
3694 ::fidl_next::EncodeOption<
3695 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3696 ___E,
3697 > for DeviceGetInterruptModesResponse
3698 where
3699 ___E: ::fidl_next::Encoder + ?Sized,
3700 DeviceGetInterruptModesResponse:
3701 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
3702 {
3703 #[inline]
3704 fn encode_option(
3705 this: ::core::option::Option<Self>,
3706 encoder: &mut ___E,
3707 out: &mut ::core::mem::MaybeUninit<
3708 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3709 >,
3710 _: (),
3711 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3712 if let Some(inner) = this {
3713 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3714 ::fidl_next::wire::Box::encode_present(out);
3715 } else {
3716 ::fidl_next::wire::Box::encode_absent(out);
3717 }
3718
3719 Ok(())
3720 }
3721 }
3722
3723 unsafe impl<'a, ___E>
3724 ::fidl_next::EncodeOption<
3725 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3726 ___E,
3727 > for &'a DeviceGetInterruptModesResponse
3728 where
3729 ___E: ::fidl_next::Encoder + ?Sized,
3730 &'a DeviceGetInterruptModesResponse:
3731 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
3732 {
3733 #[inline]
3734 fn encode_option(
3735 this: ::core::option::Option<Self>,
3736 encoder: &mut ___E,
3737 out: &mut ::core::mem::MaybeUninit<
3738 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3739 >,
3740 _: (),
3741 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3742 if let Some(inner) = this {
3743 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3744 ::fidl_next::wire::Box::encode_present(out);
3745 } else {
3746 ::fidl_next::wire::Box::encode_absent(out);
3747 }
3748
3749 Ok(())
3750 }
3751 }
3752
3753 impl ::fidl_next::FromWire<crate::wire::DeviceGetInterruptModesResponse>
3754 for DeviceGetInterruptModesResponse
3755 {
3756 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3757 crate::wire::DeviceGetInterruptModesResponse,
3758 Self,
3759 > = unsafe {
3760 ::fidl_next::CopyOptimization::enable_if(
3761 true && <crate::natural::InterruptModes as ::fidl_next::FromWire<
3762 crate::wire::InterruptModes,
3763 >>::COPY_OPTIMIZATION
3764 .is_enabled(),
3765 )
3766 };
3767
3768 #[inline]
3769 fn from_wire(wire: crate::wire::DeviceGetInterruptModesResponse) -> Self {
3770 Self { modes: ::fidl_next::FromWire::from_wire(wire.modes) }
3771 }
3772 }
3773
3774 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetInterruptModesResponse>
3775 for DeviceGetInterruptModesResponse
3776 {
3777 #[inline]
3778 fn from_wire_ref(wire: &crate::wire::DeviceGetInterruptModesResponse) -> Self {
3779 Self { modes: ::fidl_next::FromWireRef::from_wire_ref(&wire.modes) }
3780 }
3781 }
3782
3783 pub type DeviceSetInterruptModeResponse = ();
3784
3785 #[doc = " An offset from the beginning of a device\'s PCIe configuration space. [0, 0x800) is valid.\n"]
3786 pub type ExtendedConfigOffset = u16;
3787
3788 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3789 #[repr(C)]
3790 pub struct DeviceReadConfig8Request {
3791 pub offset: u16,
3792 }
3793
3794 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
3795 for DeviceReadConfig8Request
3796 where
3797 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3798 {
3799 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3800 Self,
3801 crate::wire::DeviceReadConfig8Request,
3802 > = unsafe {
3803 ::fidl_next::CopyOptimization::enable_if(
3804 true
3805
3806 && <
3807 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
3808 >::COPY_OPTIMIZATION.is_enabled()
3809
3810 )
3811 };
3812
3813 #[inline]
3814 fn encode(
3815 self,
3816 encoder_: &mut ___E,
3817 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
3818 _: (),
3819 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3820 ::fidl_next::munge! {
3821 let crate::wire::DeviceReadConfig8Request {
3822 offset,
3823
3824 } = out_;
3825 }
3826
3827 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
3828
3829 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
3830
3831 Ok(())
3832 }
3833 }
3834
3835 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
3836 for &'a DeviceReadConfig8Request
3837 where
3838 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3839 {
3840 #[inline]
3841 fn encode(
3842 self,
3843 encoder_: &mut ___E,
3844 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
3845 _: (),
3846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3847 ::fidl_next::munge! {
3848 let crate::wire::DeviceReadConfig8Request {
3849 offset,
3850
3851 } = out_;
3852 }
3853
3854 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
3855
3856 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
3857
3858 Ok(())
3859 }
3860 }
3861
3862 unsafe impl<___E>
3863 ::fidl_next::EncodeOption<
3864 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3865 ___E,
3866 > for DeviceReadConfig8Request
3867 where
3868 ___E: ::fidl_next::Encoder + ?Sized,
3869 DeviceReadConfig8Request: ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
3870 {
3871 #[inline]
3872 fn encode_option(
3873 this: ::core::option::Option<Self>,
3874 encoder: &mut ___E,
3875 out: &mut ::core::mem::MaybeUninit<
3876 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3877 >,
3878 _: (),
3879 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3880 if let Some(inner) = this {
3881 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3882 ::fidl_next::wire::Box::encode_present(out);
3883 } else {
3884 ::fidl_next::wire::Box::encode_absent(out);
3885 }
3886
3887 Ok(())
3888 }
3889 }
3890
3891 unsafe impl<'a, ___E>
3892 ::fidl_next::EncodeOption<
3893 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3894 ___E,
3895 > for &'a DeviceReadConfig8Request
3896 where
3897 ___E: ::fidl_next::Encoder + ?Sized,
3898 &'a DeviceReadConfig8Request:
3899 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
3900 {
3901 #[inline]
3902 fn encode_option(
3903 this: ::core::option::Option<Self>,
3904 encoder: &mut ___E,
3905 out: &mut ::core::mem::MaybeUninit<
3906 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
3907 >,
3908 _: (),
3909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3910 if let Some(inner) = this {
3911 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3912 ::fidl_next::wire::Box::encode_present(out);
3913 } else {
3914 ::fidl_next::wire::Box::encode_absent(out);
3915 }
3916
3917 Ok(())
3918 }
3919 }
3920
3921 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
3922 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3923 crate::wire::DeviceReadConfig8Request,
3924 Self,
3925 > = unsafe {
3926 ::fidl_next::CopyOptimization::enable_if(
3927 true
3928 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
3929 .is_enabled(),
3930 )
3931 };
3932
3933 #[inline]
3934 fn from_wire(wire: crate::wire::DeviceReadConfig8Request) -> Self {
3935 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
3936 }
3937 }
3938
3939 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
3940 #[inline]
3941 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Request) -> Self {
3942 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
3943 }
3944 }
3945
3946 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3947 #[repr(C)]
3948 pub struct DeviceReadConfig8Response {
3949 pub value: u8,
3950 }
3951
3952 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
3953 for DeviceReadConfig8Response
3954 where
3955 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3956 {
3957 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3958 Self,
3959 crate::wire::DeviceReadConfig8Response,
3960 > = unsafe {
3961 ::fidl_next::CopyOptimization::enable_if(
3962 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
3963 )
3964 };
3965
3966 #[inline]
3967 fn encode(
3968 self,
3969 encoder_: &mut ___E,
3970 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
3971 _: (),
3972 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3973 ::fidl_next::munge! {
3974 let crate::wire::DeviceReadConfig8Response {
3975 value,
3976
3977 } = out_;
3978 }
3979
3980 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
3981
3982 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
3983
3984 Ok(())
3985 }
3986 }
3987
3988 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
3989 for &'a DeviceReadConfig8Response
3990 where
3991 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3992 {
3993 #[inline]
3994 fn encode(
3995 self,
3996 encoder_: &mut ___E,
3997 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
3998 _: (),
3999 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4000 ::fidl_next::munge! {
4001 let crate::wire::DeviceReadConfig8Response {
4002 value,
4003
4004 } = out_;
4005 }
4006
4007 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4008
4009 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4010
4011 Ok(())
4012 }
4013 }
4014
4015 unsafe impl<___E>
4016 ::fidl_next::EncodeOption<
4017 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4018 ___E,
4019 > for DeviceReadConfig8Response
4020 where
4021 ___E: ::fidl_next::Encoder + ?Sized,
4022 DeviceReadConfig8Response:
4023 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4024 {
4025 #[inline]
4026 fn encode_option(
4027 this: ::core::option::Option<Self>,
4028 encoder: &mut ___E,
4029 out: &mut ::core::mem::MaybeUninit<
4030 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4031 >,
4032 _: (),
4033 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4034 if let Some(inner) = this {
4035 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4036 ::fidl_next::wire::Box::encode_present(out);
4037 } else {
4038 ::fidl_next::wire::Box::encode_absent(out);
4039 }
4040
4041 Ok(())
4042 }
4043 }
4044
4045 unsafe impl<'a, ___E>
4046 ::fidl_next::EncodeOption<
4047 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4048 ___E,
4049 > for &'a DeviceReadConfig8Response
4050 where
4051 ___E: ::fidl_next::Encoder + ?Sized,
4052 &'a DeviceReadConfig8Response:
4053 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4054 {
4055 #[inline]
4056 fn encode_option(
4057 this: ::core::option::Option<Self>,
4058 encoder: &mut ___E,
4059 out: &mut ::core::mem::MaybeUninit<
4060 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4061 >,
4062 _: (),
4063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4064 if let Some(inner) = this {
4065 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4066 ::fidl_next::wire::Box::encode_present(out);
4067 } else {
4068 ::fidl_next::wire::Box::encode_absent(out);
4069 }
4070
4071 Ok(())
4072 }
4073 }
4074
4075 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Response> for DeviceReadConfig8Response {
4076 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4077 crate::wire::DeviceReadConfig8Response,
4078 Self,
4079 > = unsafe {
4080 ::fidl_next::CopyOptimization::enable_if(
4081 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
4082 )
4083 };
4084
4085 #[inline]
4086 fn from_wire(wire: crate::wire::DeviceReadConfig8Response) -> Self {
4087 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4088 }
4089 }
4090
4091 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Response>
4092 for DeviceReadConfig8Response
4093 {
4094 #[inline]
4095 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Response) -> Self {
4096 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4097 }
4098 }
4099
4100 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4101 #[repr(C)]
4102 pub struct DeviceReadConfig16Request {
4103 pub offset: u16,
4104 }
4105
4106 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4107 for DeviceReadConfig16Request
4108 where
4109 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4110 {
4111 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4112 Self,
4113 crate::wire::DeviceReadConfig16Request,
4114 > = unsafe {
4115 ::fidl_next::CopyOptimization::enable_if(
4116 true
4117
4118 && <
4119 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4120 >::COPY_OPTIMIZATION.is_enabled()
4121
4122 )
4123 };
4124
4125 #[inline]
4126 fn encode(
4127 self,
4128 encoder_: &mut ___E,
4129 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4130 _: (),
4131 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4132 ::fidl_next::munge! {
4133 let crate::wire::DeviceReadConfig16Request {
4134 offset,
4135
4136 } = out_;
4137 }
4138
4139 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4140
4141 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4142
4143 Ok(())
4144 }
4145 }
4146
4147 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4148 for &'a DeviceReadConfig16Request
4149 where
4150 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4151 {
4152 #[inline]
4153 fn encode(
4154 self,
4155 encoder_: &mut ___E,
4156 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4157 _: (),
4158 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4159 ::fidl_next::munge! {
4160 let crate::wire::DeviceReadConfig16Request {
4161 offset,
4162
4163 } = out_;
4164 }
4165
4166 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4167
4168 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4169
4170 Ok(())
4171 }
4172 }
4173
4174 unsafe impl<___E>
4175 ::fidl_next::EncodeOption<
4176 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4177 ___E,
4178 > for DeviceReadConfig16Request
4179 where
4180 ___E: ::fidl_next::Encoder + ?Sized,
4181 DeviceReadConfig16Request:
4182 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4183 {
4184 #[inline]
4185 fn encode_option(
4186 this: ::core::option::Option<Self>,
4187 encoder: &mut ___E,
4188 out: &mut ::core::mem::MaybeUninit<
4189 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4190 >,
4191 _: (),
4192 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4193 if let Some(inner) = this {
4194 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4195 ::fidl_next::wire::Box::encode_present(out);
4196 } else {
4197 ::fidl_next::wire::Box::encode_absent(out);
4198 }
4199
4200 Ok(())
4201 }
4202 }
4203
4204 unsafe impl<'a, ___E>
4205 ::fidl_next::EncodeOption<
4206 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4207 ___E,
4208 > for &'a DeviceReadConfig16Request
4209 where
4210 ___E: ::fidl_next::Encoder + ?Sized,
4211 &'a DeviceReadConfig16Request:
4212 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4213 {
4214 #[inline]
4215 fn encode_option(
4216 this: ::core::option::Option<Self>,
4217 encoder: &mut ___E,
4218 out: &mut ::core::mem::MaybeUninit<
4219 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4220 >,
4221 _: (),
4222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4223 if let Some(inner) = this {
4224 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4225 ::fidl_next::wire::Box::encode_present(out);
4226 } else {
4227 ::fidl_next::wire::Box::encode_absent(out);
4228 }
4229
4230 Ok(())
4231 }
4232 }
4233
4234 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Request> for DeviceReadConfig16Request {
4235 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4236 crate::wire::DeviceReadConfig16Request,
4237 Self,
4238 > = unsafe {
4239 ::fidl_next::CopyOptimization::enable_if(
4240 true
4241 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4242 .is_enabled(),
4243 )
4244 };
4245
4246 #[inline]
4247 fn from_wire(wire: crate::wire::DeviceReadConfig16Request) -> Self {
4248 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4249 }
4250 }
4251
4252 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Request>
4253 for DeviceReadConfig16Request
4254 {
4255 #[inline]
4256 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Request) -> Self {
4257 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4258 }
4259 }
4260
4261 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4262 #[repr(C)]
4263 pub struct DeviceReadConfig16Response {
4264 pub value: u16,
4265 }
4266
4267 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4268 for DeviceReadConfig16Response
4269 where
4270 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4271 {
4272 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4273 Self,
4274 crate::wire::DeviceReadConfig16Response,
4275 > = unsafe {
4276 ::fidl_next::CopyOptimization::enable_if(
4277 true
4278
4279 && <
4280 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4281 >::COPY_OPTIMIZATION.is_enabled()
4282
4283 )
4284 };
4285
4286 #[inline]
4287 fn encode(
4288 self,
4289 encoder_: &mut ___E,
4290 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4291 _: (),
4292 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4293 ::fidl_next::munge! {
4294 let crate::wire::DeviceReadConfig16Response {
4295 value,
4296
4297 } = out_;
4298 }
4299
4300 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4301
4302 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4303
4304 Ok(())
4305 }
4306 }
4307
4308 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4309 for &'a DeviceReadConfig16Response
4310 where
4311 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4312 {
4313 #[inline]
4314 fn encode(
4315 self,
4316 encoder_: &mut ___E,
4317 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4318 _: (),
4319 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4320 ::fidl_next::munge! {
4321 let crate::wire::DeviceReadConfig16Response {
4322 value,
4323
4324 } = out_;
4325 }
4326
4327 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4328
4329 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4330
4331 Ok(())
4332 }
4333 }
4334
4335 unsafe impl<___E>
4336 ::fidl_next::EncodeOption<
4337 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4338 ___E,
4339 > for DeviceReadConfig16Response
4340 where
4341 ___E: ::fidl_next::Encoder + ?Sized,
4342 DeviceReadConfig16Response:
4343 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4344 {
4345 #[inline]
4346 fn encode_option(
4347 this: ::core::option::Option<Self>,
4348 encoder: &mut ___E,
4349 out: &mut ::core::mem::MaybeUninit<
4350 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4351 >,
4352 _: (),
4353 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4354 if let Some(inner) = this {
4355 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4356 ::fidl_next::wire::Box::encode_present(out);
4357 } else {
4358 ::fidl_next::wire::Box::encode_absent(out);
4359 }
4360
4361 Ok(())
4362 }
4363 }
4364
4365 unsafe impl<'a, ___E>
4366 ::fidl_next::EncodeOption<
4367 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4368 ___E,
4369 > for &'a DeviceReadConfig16Response
4370 where
4371 ___E: ::fidl_next::Encoder + ?Sized,
4372 &'a DeviceReadConfig16Response:
4373 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4374 {
4375 #[inline]
4376 fn encode_option(
4377 this: ::core::option::Option<Self>,
4378 encoder: &mut ___E,
4379 out: &mut ::core::mem::MaybeUninit<
4380 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4381 >,
4382 _: (),
4383 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4384 if let Some(inner) = this {
4385 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4386 ::fidl_next::wire::Box::encode_present(out);
4387 } else {
4388 ::fidl_next::wire::Box::encode_absent(out);
4389 }
4390
4391 Ok(())
4392 }
4393 }
4394
4395 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Response> for DeviceReadConfig16Response {
4396 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4397 crate::wire::DeviceReadConfig16Response,
4398 Self,
4399 > = unsafe {
4400 ::fidl_next::CopyOptimization::enable_if(
4401 true
4402 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4403 .is_enabled(),
4404 )
4405 };
4406
4407 #[inline]
4408 fn from_wire(wire: crate::wire::DeviceReadConfig16Response) -> Self {
4409 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4410 }
4411 }
4412
4413 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Response>
4414 for DeviceReadConfig16Response
4415 {
4416 #[inline]
4417 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Response) -> Self {
4418 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4419 }
4420 }
4421
4422 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4423 #[repr(C)]
4424 pub struct DeviceReadConfig32Request {
4425 pub offset: u16,
4426 }
4427
4428 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
4429 for DeviceReadConfig32Request
4430 where
4431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4432 {
4433 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4434 Self,
4435 crate::wire::DeviceReadConfig32Request,
4436 > = unsafe {
4437 ::fidl_next::CopyOptimization::enable_if(
4438 true
4439
4440 && <
4441 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4442 >::COPY_OPTIMIZATION.is_enabled()
4443
4444 )
4445 };
4446
4447 #[inline]
4448 fn encode(
4449 self,
4450 encoder_: &mut ___E,
4451 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
4452 _: (),
4453 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4454 ::fidl_next::munge! {
4455 let crate::wire::DeviceReadConfig32Request {
4456 offset,
4457
4458 } = out_;
4459 }
4460
4461 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4462
4463 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4464
4465 Ok(())
4466 }
4467 }
4468
4469 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
4470 for &'a DeviceReadConfig32Request
4471 where
4472 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4473 {
4474 #[inline]
4475 fn encode(
4476 self,
4477 encoder_: &mut ___E,
4478 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
4479 _: (),
4480 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4481 ::fidl_next::munge! {
4482 let crate::wire::DeviceReadConfig32Request {
4483 offset,
4484
4485 } = out_;
4486 }
4487
4488 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4489
4490 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4491
4492 Ok(())
4493 }
4494 }
4495
4496 unsafe impl<___E>
4497 ::fidl_next::EncodeOption<
4498 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4499 ___E,
4500 > for DeviceReadConfig32Request
4501 where
4502 ___E: ::fidl_next::Encoder + ?Sized,
4503 DeviceReadConfig32Request:
4504 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
4505 {
4506 #[inline]
4507 fn encode_option(
4508 this: ::core::option::Option<Self>,
4509 encoder: &mut ___E,
4510 out: &mut ::core::mem::MaybeUninit<
4511 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4512 >,
4513 _: (),
4514 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4515 if let Some(inner) = this {
4516 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4517 ::fidl_next::wire::Box::encode_present(out);
4518 } else {
4519 ::fidl_next::wire::Box::encode_absent(out);
4520 }
4521
4522 Ok(())
4523 }
4524 }
4525
4526 unsafe impl<'a, ___E>
4527 ::fidl_next::EncodeOption<
4528 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4529 ___E,
4530 > for &'a DeviceReadConfig32Request
4531 where
4532 ___E: ::fidl_next::Encoder + ?Sized,
4533 &'a DeviceReadConfig32Request:
4534 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
4535 {
4536 #[inline]
4537 fn encode_option(
4538 this: ::core::option::Option<Self>,
4539 encoder: &mut ___E,
4540 out: &mut ::core::mem::MaybeUninit<
4541 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
4542 >,
4543 _: (),
4544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4545 if let Some(inner) = this {
4546 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4547 ::fidl_next::wire::Box::encode_present(out);
4548 } else {
4549 ::fidl_next::wire::Box::encode_absent(out);
4550 }
4551
4552 Ok(())
4553 }
4554 }
4555
4556 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Request> for DeviceReadConfig32Request {
4557 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4558 crate::wire::DeviceReadConfig32Request,
4559 Self,
4560 > = unsafe {
4561 ::fidl_next::CopyOptimization::enable_if(
4562 true
4563 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4564 .is_enabled(),
4565 )
4566 };
4567
4568 #[inline]
4569 fn from_wire(wire: crate::wire::DeviceReadConfig32Request) -> Self {
4570 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4571 }
4572 }
4573
4574 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Request>
4575 for DeviceReadConfig32Request
4576 {
4577 #[inline]
4578 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Request) -> Self {
4579 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4580 }
4581 }
4582
4583 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4584 #[repr(C)]
4585 pub struct DeviceReadConfig32Response {
4586 pub value: u32,
4587 }
4588
4589 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
4590 for DeviceReadConfig32Response
4591 where
4592 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4593 {
4594 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4595 Self,
4596 crate::wire::DeviceReadConfig32Response,
4597 > = unsafe {
4598 ::fidl_next::CopyOptimization::enable_if(
4599 true
4600
4601 && <
4602 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
4603 >::COPY_OPTIMIZATION.is_enabled()
4604
4605 )
4606 };
4607
4608 #[inline]
4609 fn encode(
4610 self,
4611 encoder_: &mut ___E,
4612 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
4613 _: (),
4614 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4615 ::fidl_next::munge! {
4616 let crate::wire::DeviceReadConfig32Response {
4617 value,
4618
4619 } = out_;
4620 }
4621
4622 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4623
4624 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4625
4626 Ok(())
4627 }
4628 }
4629
4630 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
4631 for &'a DeviceReadConfig32Response
4632 where
4633 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4634 {
4635 #[inline]
4636 fn encode(
4637 self,
4638 encoder_: &mut ___E,
4639 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
4640 _: (),
4641 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4642 ::fidl_next::munge! {
4643 let crate::wire::DeviceReadConfig32Response {
4644 value,
4645
4646 } = out_;
4647 }
4648
4649 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4650
4651 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4652
4653 Ok(())
4654 }
4655 }
4656
4657 unsafe impl<___E>
4658 ::fidl_next::EncodeOption<
4659 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4660 ___E,
4661 > for DeviceReadConfig32Response
4662 where
4663 ___E: ::fidl_next::Encoder + ?Sized,
4664 DeviceReadConfig32Response:
4665 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
4666 {
4667 #[inline]
4668 fn encode_option(
4669 this: ::core::option::Option<Self>,
4670 encoder: &mut ___E,
4671 out: &mut ::core::mem::MaybeUninit<
4672 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4673 >,
4674 _: (),
4675 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4676 if let Some(inner) = this {
4677 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4678 ::fidl_next::wire::Box::encode_present(out);
4679 } else {
4680 ::fidl_next::wire::Box::encode_absent(out);
4681 }
4682
4683 Ok(())
4684 }
4685 }
4686
4687 unsafe impl<'a, ___E>
4688 ::fidl_next::EncodeOption<
4689 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4690 ___E,
4691 > for &'a DeviceReadConfig32Response
4692 where
4693 ___E: ::fidl_next::Encoder + ?Sized,
4694 &'a DeviceReadConfig32Response:
4695 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
4696 {
4697 #[inline]
4698 fn encode_option(
4699 this: ::core::option::Option<Self>,
4700 encoder: &mut ___E,
4701 out: &mut ::core::mem::MaybeUninit<
4702 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
4703 >,
4704 _: (),
4705 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4706 if let Some(inner) = this {
4707 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4708 ::fidl_next::wire::Box::encode_present(out);
4709 } else {
4710 ::fidl_next::wire::Box::encode_absent(out);
4711 }
4712
4713 Ok(())
4714 }
4715 }
4716
4717 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Response> for DeviceReadConfig32Response {
4718 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4719 crate::wire::DeviceReadConfig32Response,
4720 Self,
4721 > = unsafe {
4722 ::fidl_next::CopyOptimization::enable_if(
4723 true
4724 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
4725 .is_enabled(),
4726 )
4727 };
4728
4729 #[inline]
4730 fn from_wire(wire: crate::wire::DeviceReadConfig32Response) -> Self {
4731 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4732 }
4733 }
4734
4735 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Response>
4736 for DeviceReadConfig32Response
4737 {
4738 #[inline]
4739 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Response) -> Self {
4740 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4741 }
4742 }
4743
4744 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4745 pub struct DeviceWriteConfig8Request {
4746 pub offset: u16,
4747
4748 pub value: u8,
4749 }
4750
4751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
4752 for DeviceWriteConfig8Request
4753 where
4754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4755 {
4756 #[inline]
4757 fn encode(
4758 self,
4759 encoder_: &mut ___E,
4760 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
4761 _: (),
4762 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4763 ::fidl_next::munge! {
4764 let crate::wire::DeviceWriteConfig8Request {
4765 offset,
4766 value,
4767
4768 } = out_;
4769 }
4770
4771 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4772
4773 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4774
4775 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4776
4777 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4778
4779 Ok(())
4780 }
4781 }
4782
4783 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
4784 for &'a DeviceWriteConfig8Request
4785 where
4786 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4787 {
4788 #[inline]
4789 fn encode(
4790 self,
4791 encoder_: &mut ___E,
4792 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
4793 _: (),
4794 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4795 ::fidl_next::munge! {
4796 let crate::wire::DeviceWriteConfig8Request {
4797 offset,
4798 value,
4799
4800 } = out_;
4801 }
4802
4803 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4804
4805 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4806
4807 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4808
4809 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4810
4811 Ok(())
4812 }
4813 }
4814
4815 unsafe impl<___E>
4816 ::fidl_next::EncodeOption<
4817 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4818 ___E,
4819 > for DeviceWriteConfig8Request
4820 where
4821 ___E: ::fidl_next::Encoder + ?Sized,
4822 DeviceWriteConfig8Request:
4823 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
4824 {
4825 #[inline]
4826 fn encode_option(
4827 this: ::core::option::Option<Self>,
4828 encoder: &mut ___E,
4829 out: &mut ::core::mem::MaybeUninit<
4830 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4831 >,
4832 _: (),
4833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4834 if let Some(inner) = this {
4835 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4836 ::fidl_next::wire::Box::encode_present(out);
4837 } else {
4838 ::fidl_next::wire::Box::encode_absent(out);
4839 }
4840
4841 Ok(())
4842 }
4843 }
4844
4845 unsafe impl<'a, ___E>
4846 ::fidl_next::EncodeOption<
4847 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4848 ___E,
4849 > for &'a DeviceWriteConfig8Request
4850 where
4851 ___E: ::fidl_next::Encoder + ?Sized,
4852 &'a DeviceWriteConfig8Request:
4853 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
4854 {
4855 #[inline]
4856 fn encode_option(
4857 this: ::core::option::Option<Self>,
4858 encoder: &mut ___E,
4859 out: &mut ::core::mem::MaybeUninit<
4860 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
4861 >,
4862 _: (),
4863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4864 if let Some(inner) = this {
4865 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4866 ::fidl_next::wire::Box::encode_present(out);
4867 } else {
4868 ::fidl_next::wire::Box::encode_absent(out);
4869 }
4870
4871 Ok(())
4872 }
4873 }
4874
4875 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig8Request> for DeviceWriteConfig8Request {
4876 #[inline]
4877 fn from_wire(wire: crate::wire::DeviceWriteConfig8Request) -> Self {
4878 Self {
4879 offset: ::fidl_next::FromWire::from_wire(wire.offset),
4880
4881 value: ::fidl_next::FromWire::from_wire(wire.value),
4882 }
4883 }
4884 }
4885
4886 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig8Request>
4887 for DeviceWriteConfig8Request
4888 {
4889 #[inline]
4890 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig8Request) -> Self {
4891 Self {
4892 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
4893
4894 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
4895 }
4896 }
4897 }
4898
4899 pub type DeviceWriteConfig8Response = ();
4900
4901 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4902 #[repr(C)]
4903 pub struct DeviceWriteConfig16Request {
4904 pub offset: u16,
4905
4906 pub value: u16,
4907 }
4908
4909 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
4910 for DeviceWriteConfig16Request
4911 where
4912 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4913 {
4914 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4915 Self,
4916 crate::wire::DeviceWriteConfig16Request,
4917 > = unsafe {
4918 ::fidl_next::CopyOptimization::enable_if(
4919 true
4920
4921 && <
4922 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4923 >::COPY_OPTIMIZATION.is_enabled()
4924
4925 && <
4926 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4927 >::COPY_OPTIMIZATION.is_enabled()
4928
4929 )
4930 };
4931
4932 #[inline]
4933 fn encode(
4934 self,
4935 encoder_: &mut ___E,
4936 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
4937 _: (),
4938 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4939 ::fidl_next::munge! {
4940 let crate::wire::DeviceWriteConfig16Request {
4941 offset,
4942 value,
4943
4944 } = out_;
4945 }
4946
4947 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4948
4949 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4950
4951 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4952
4953 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4954
4955 Ok(())
4956 }
4957 }
4958
4959 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
4960 for &'a DeviceWriteConfig16Request
4961 where
4962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4963 {
4964 #[inline]
4965 fn encode(
4966 self,
4967 encoder_: &mut ___E,
4968 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
4969 _: (),
4970 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4971 ::fidl_next::munge! {
4972 let crate::wire::DeviceWriteConfig16Request {
4973 offset,
4974 value,
4975
4976 } = out_;
4977 }
4978
4979 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4980
4981 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4982
4983 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4984
4985 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4986
4987 Ok(())
4988 }
4989 }
4990
4991 unsafe impl<___E>
4992 ::fidl_next::EncodeOption<
4993 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
4994 ___E,
4995 > for DeviceWriteConfig16Request
4996 where
4997 ___E: ::fidl_next::Encoder + ?Sized,
4998 DeviceWriteConfig16Request:
4999 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5000 {
5001 #[inline]
5002 fn encode_option(
5003 this: ::core::option::Option<Self>,
5004 encoder: &mut ___E,
5005 out: &mut ::core::mem::MaybeUninit<
5006 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5007 >,
5008 _: (),
5009 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5010 if let Some(inner) = this {
5011 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5012 ::fidl_next::wire::Box::encode_present(out);
5013 } else {
5014 ::fidl_next::wire::Box::encode_absent(out);
5015 }
5016
5017 Ok(())
5018 }
5019 }
5020
5021 unsafe impl<'a, ___E>
5022 ::fidl_next::EncodeOption<
5023 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5024 ___E,
5025 > for &'a DeviceWriteConfig16Request
5026 where
5027 ___E: ::fidl_next::Encoder + ?Sized,
5028 &'a DeviceWriteConfig16Request:
5029 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5030 {
5031 #[inline]
5032 fn encode_option(
5033 this: ::core::option::Option<Self>,
5034 encoder: &mut ___E,
5035 out: &mut ::core::mem::MaybeUninit<
5036 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5037 >,
5038 _: (),
5039 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5040 if let Some(inner) = this {
5041 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5042 ::fidl_next::wire::Box::encode_present(out);
5043 } else {
5044 ::fidl_next::wire::Box::encode_absent(out);
5045 }
5046
5047 Ok(())
5048 }
5049 }
5050
5051 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig16Request> for DeviceWriteConfig16Request {
5052 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5053 crate::wire::DeviceWriteConfig16Request,
5054 Self,
5055 > = unsafe {
5056 ::fidl_next::CopyOptimization::enable_if(
5057 true
5058 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5059 .is_enabled()
5060 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5061 .is_enabled(),
5062 )
5063 };
5064
5065 #[inline]
5066 fn from_wire(wire: crate::wire::DeviceWriteConfig16Request) -> Self {
5067 Self {
5068 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5069
5070 value: ::fidl_next::FromWire::from_wire(wire.value),
5071 }
5072 }
5073 }
5074
5075 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig16Request>
5076 for DeviceWriteConfig16Request
5077 {
5078 #[inline]
5079 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig16Request) -> Self {
5080 Self {
5081 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5082
5083 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5084 }
5085 }
5086 }
5087
5088 pub type DeviceWriteConfig16Response = ();
5089
5090 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5091 pub struct DeviceWriteConfig32Request {
5092 pub offset: u16,
5093
5094 pub value: u32,
5095 }
5096
5097 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5098 for DeviceWriteConfig32Request
5099 where
5100 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5101 {
5102 #[inline]
5103 fn encode(
5104 self,
5105 encoder_: &mut ___E,
5106 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5107 _: (),
5108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5109 ::fidl_next::munge! {
5110 let crate::wire::DeviceWriteConfig32Request {
5111 offset,
5112 value,
5113
5114 } = out_;
5115 }
5116
5117 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5118
5119 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5120
5121 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5122
5123 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5124
5125 Ok(())
5126 }
5127 }
5128
5129 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5130 for &'a DeviceWriteConfig32Request
5131 where
5132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5133 {
5134 #[inline]
5135 fn encode(
5136 self,
5137 encoder_: &mut ___E,
5138 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5139 _: (),
5140 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5141 ::fidl_next::munge! {
5142 let crate::wire::DeviceWriteConfig32Request {
5143 offset,
5144 value,
5145
5146 } = out_;
5147 }
5148
5149 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5150
5151 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5152
5153 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5154
5155 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5156
5157 Ok(())
5158 }
5159 }
5160
5161 unsafe impl<___E>
5162 ::fidl_next::EncodeOption<
5163 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5164 ___E,
5165 > for DeviceWriteConfig32Request
5166 where
5167 ___E: ::fidl_next::Encoder + ?Sized,
5168 DeviceWriteConfig32Request:
5169 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5170 {
5171 #[inline]
5172 fn encode_option(
5173 this: ::core::option::Option<Self>,
5174 encoder: &mut ___E,
5175 out: &mut ::core::mem::MaybeUninit<
5176 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5177 >,
5178 _: (),
5179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5180 if let Some(inner) = this {
5181 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5182 ::fidl_next::wire::Box::encode_present(out);
5183 } else {
5184 ::fidl_next::wire::Box::encode_absent(out);
5185 }
5186
5187 Ok(())
5188 }
5189 }
5190
5191 unsafe impl<'a, ___E>
5192 ::fidl_next::EncodeOption<
5193 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5194 ___E,
5195 > for &'a DeviceWriteConfig32Request
5196 where
5197 ___E: ::fidl_next::Encoder + ?Sized,
5198 &'a DeviceWriteConfig32Request:
5199 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5200 {
5201 #[inline]
5202 fn encode_option(
5203 this: ::core::option::Option<Self>,
5204 encoder: &mut ___E,
5205 out: &mut ::core::mem::MaybeUninit<
5206 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5207 >,
5208 _: (),
5209 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5210 if let Some(inner) = this {
5211 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5212 ::fidl_next::wire::Box::encode_present(out);
5213 } else {
5214 ::fidl_next::wire::Box::encode_absent(out);
5215 }
5216
5217 Ok(())
5218 }
5219 }
5220
5221 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig32Request> for DeviceWriteConfig32Request {
5222 #[inline]
5223 fn from_wire(wire: crate::wire::DeviceWriteConfig32Request) -> Self {
5224 Self {
5225 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5226
5227 value: ::fidl_next::FromWire::from_wire(wire.value),
5228 }
5229 }
5230 }
5231
5232 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig32Request>
5233 for DeviceWriteConfig32Request
5234 {
5235 #[inline]
5236 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig32Request) -> Self {
5237 Self {
5238 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5239
5240 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5241 }
5242 }
5243 }
5244
5245 pub type DeviceWriteConfig32Response = ();
5246
5247 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5248 #[repr(C)]
5249 pub struct DeviceGetCapabilitiesRequest {
5250 pub id: crate::natural::CapabilityId,
5251 }
5252
5253 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5254 for DeviceGetCapabilitiesRequest
5255 where
5256 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5257 {
5258 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5259 Self,
5260 crate::wire::DeviceGetCapabilitiesRequest,
5261 > = unsafe {
5262 ::fidl_next::CopyOptimization::enable_if(
5263 true && <crate::natural::CapabilityId as ::fidl_next::Encode<
5264 crate::wire::CapabilityId,
5265 ___E,
5266 >>::COPY_OPTIMIZATION
5267 .is_enabled(),
5268 )
5269 };
5270
5271 #[inline]
5272 fn encode(
5273 self,
5274 encoder_: &mut ___E,
5275 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5276 _: (),
5277 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5278 ::fidl_next::munge! {
5279 let crate::wire::DeviceGetCapabilitiesRequest {
5280 id,
5281
5282 } = out_;
5283 }
5284
5285 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5286
5287 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5288
5289 Ok(())
5290 }
5291 }
5292
5293 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5294 for &'a DeviceGetCapabilitiesRequest
5295 where
5296 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5297 {
5298 #[inline]
5299 fn encode(
5300 self,
5301 encoder_: &mut ___E,
5302 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5303 _: (),
5304 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5305 ::fidl_next::munge! {
5306 let crate::wire::DeviceGetCapabilitiesRequest {
5307 id,
5308
5309 } = out_;
5310 }
5311
5312 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
5313
5314 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5315
5316 Ok(())
5317 }
5318 }
5319
5320 unsafe impl<___E>
5321 ::fidl_next::EncodeOption<
5322 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5323 ___E,
5324 > for DeviceGetCapabilitiesRequest
5325 where
5326 ___E: ::fidl_next::Encoder + ?Sized,
5327 DeviceGetCapabilitiesRequest:
5328 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5329 {
5330 #[inline]
5331 fn encode_option(
5332 this: ::core::option::Option<Self>,
5333 encoder: &mut ___E,
5334 out: &mut ::core::mem::MaybeUninit<
5335 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5336 >,
5337 _: (),
5338 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5339 if let Some(inner) = this {
5340 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5341 ::fidl_next::wire::Box::encode_present(out);
5342 } else {
5343 ::fidl_next::wire::Box::encode_absent(out);
5344 }
5345
5346 Ok(())
5347 }
5348 }
5349
5350 unsafe impl<'a, ___E>
5351 ::fidl_next::EncodeOption<
5352 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5353 ___E,
5354 > for &'a DeviceGetCapabilitiesRequest
5355 where
5356 ___E: ::fidl_next::Encoder + ?Sized,
5357 &'a DeviceGetCapabilitiesRequest:
5358 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5359 {
5360 #[inline]
5361 fn encode_option(
5362 this: ::core::option::Option<Self>,
5363 encoder: &mut ___E,
5364 out: &mut ::core::mem::MaybeUninit<
5365 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5366 >,
5367 _: (),
5368 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5369 if let Some(inner) = this {
5370 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5371 ::fidl_next::wire::Box::encode_present(out);
5372 } else {
5373 ::fidl_next::wire::Box::encode_absent(out);
5374 }
5375
5376 Ok(())
5377 }
5378 }
5379
5380 impl ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesRequest>
5381 for DeviceGetCapabilitiesRequest
5382 {
5383 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5384 crate::wire::DeviceGetCapabilitiesRequest,
5385 Self,
5386 > = unsafe {
5387 ::fidl_next::CopyOptimization::enable_if(
5388 true && <crate::natural::CapabilityId as ::fidl_next::FromWire<
5389 crate::wire::CapabilityId,
5390 >>::COPY_OPTIMIZATION
5391 .is_enabled(),
5392 )
5393 };
5394
5395 #[inline]
5396 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5397 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
5398 }
5399 }
5400
5401 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesRequest>
5402 for DeviceGetCapabilitiesRequest
5403 {
5404 #[inline]
5405 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5406 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
5407 }
5408 }
5409
5410 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5411 pub struct DeviceGetCapabilitiesResponse {
5412 pub offsets: ::std::vec::Vec<u8>,
5413 }
5414
5415 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
5416 for DeviceGetCapabilitiesResponse
5417 where
5418 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5419 ___E: ::fidl_next::Encoder,
5420 {
5421 #[inline]
5422 fn encode(
5423 self,
5424 encoder_: &mut ___E,
5425 out_: &mut ::core::mem::MaybeUninit<
5426 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5427 >,
5428 _: (),
5429 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5430 ::fidl_next::munge! {
5431 let crate::wire::DeviceGetCapabilitiesResponse {
5432 offsets,
5433
5434 } = out_;
5435 }
5436
5437 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
5438
5439 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
5440 ::fidl_next::Constrained::validate(_field, (32, ()))?;
5441
5442 Ok(())
5443 }
5444 }
5445
5446 unsafe impl<'a, ___E>
5447 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
5448 for &'a DeviceGetCapabilitiesResponse
5449 where
5450 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5451 ___E: ::fidl_next::Encoder,
5452 {
5453 #[inline]
5454 fn encode(
5455 self,
5456 encoder_: &mut ___E,
5457 out_: &mut ::core::mem::MaybeUninit<
5458 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5459 >,
5460 _: (),
5461 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5462 ::fidl_next::munge! {
5463 let crate::wire::DeviceGetCapabilitiesResponse {
5464 offsets,
5465
5466 } = out_;
5467 }
5468
5469 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
5470
5471 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
5472 ::fidl_next::Constrained::validate(_field, (32, ()))?;
5473
5474 Ok(())
5475 }
5476 }
5477
5478 unsafe impl<___E>
5479 ::fidl_next::EncodeOption<
5480 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
5481 ___E,
5482 > for DeviceGetCapabilitiesResponse
5483 where
5484 ___E: ::fidl_next::Encoder + ?Sized,
5485 DeviceGetCapabilitiesResponse:
5486 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
5487 {
5488 #[inline]
5489 fn encode_option(
5490 this: ::core::option::Option<Self>,
5491 encoder: &mut ___E,
5492 out: &mut ::core::mem::MaybeUninit<
5493 ::fidl_next::wire::Box<
5494 'static,
5495 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5496 >,
5497 >,
5498 _: (),
5499 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5500 if let Some(inner) = this {
5501 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5502 ::fidl_next::wire::Box::encode_present(out);
5503 } else {
5504 ::fidl_next::wire::Box::encode_absent(out);
5505 }
5506
5507 Ok(())
5508 }
5509 }
5510
5511 unsafe impl<'a, ___E>
5512 ::fidl_next::EncodeOption<
5513 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
5514 ___E,
5515 > for &'a DeviceGetCapabilitiesResponse
5516 where
5517 ___E: ::fidl_next::Encoder + ?Sized,
5518 &'a DeviceGetCapabilitiesResponse:
5519 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
5520 {
5521 #[inline]
5522 fn encode_option(
5523 this: ::core::option::Option<Self>,
5524 encoder: &mut ___E,
5525 out: &mut ::core::mem::MaybeUninit<
5526 ::fidl_next::wire::Box<
5527 'static,
5528 crate::wire::DeviceGetCapabilitiesResponse<'static>,
5529 >,
5530 >,
5531 _: (),
5532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5533 if let Some(inner) = this {
5534 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5535 ::fidl_next::wire::Box::encode_present(out);
5536 } else {
5537 ::fidl_next::wire::Box::encode_absent(out);
5538 }
5539
5540 Ok(())
5541 }
5542 }
5543
5544 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesResponse<'de>>
5545 for DeviceGetCapabilitiesResponse
5546 {
5547 #[inline]
5548 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
5549 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
5550 }
5551 }
5552
5553 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesResponse<'de>>
5554 for DeviceGetCapabilitiesResponse
5555 {
5556 #[inline]
5557 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
5558 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
5559 }
5560 }
5561
5562 #[doc = " PCI Extended Capability IDs.\n PCIe Base Specification rev4, chapter 7.6.\n"]
5563 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5564 #[repr(u16)]
5565 pub enum ExtendedCapabilityId {
5566 Null = 0,
5567 AdvancedErrorReporting = 1,
5568 VirtualChannelNoMfvc = 2,
5569 DeviceSerialNumber = 3,
5570 PowerBudgeting = 4,
5571 RootComplexLinkDeclaration = 5,
5572 RootComplexInternalLinkControl = 6,
5573 RootComplexEventCollectorEndpointAssociation = 7,
5574 MultiFunctionVirtualChannel = 8,
5575 VirtualChannel = 9,
5576 Rcrb = 10,
5577 Vendor = 11,
5578 Cac = 12,
5579 Acs = 13,
5580 Ari = 14,
5581 Ats = 15,
5582 SrIov = 16,
5583 MrIov = 17,
5584 Multicast = 18,
5585 Pri = 19,
5586 EnhancedAllocation = 20,
5587 ResizableBar = 21,
5588 DynamicPowerAllocation = 22,
5589 Tph = 23,
5590 LatencyToleranceReporting = 24,
5591 SecondaryPciExpress = 25,
5592 Pmux = 26,
5593 Pasid = 27,
5594 Lnr = 28,
5595 Dpc = 29,
5596 L1PmSubstates = 30,
5597 PrecisionTimeMeasurement = 31,
5598 Mpcie = 32,
5599 FrsQueueing = 33,
5600 ReadinessTimeReporting = 34,
5601 DesignatedVendor = 35,
5602 VfResizableBar = 36,
5603 DataLinkFeature = 37,
5604 PhysicalLayer16 = 38,
5605 LaneMarginingAtReceiver = 39,
5606 HierarchyId = 40,
5607 NativePcieEnclosure = 41,
5608 PhysicalLayer32 = 42,
5609 AlternateProtocol = 43,
5610 SystemFirmwareIntermediary = 44,
5611 UnknownOrdinal_(u16) = 45,
5612 }
5613 impl ::std::convert::From<u16> for ExtendedCapabilityId {
5614 fn from(value: u16) -> Self {
5615 match value {
5616 0 => Self::Null,
5617 1 => Self::AdvancedErrorReporting,
5618 2 => Self::VirtualChannelNoMfvc,
5619 3 => Self::DeviceSerialNumber,
5620 4 => Self::PowerBudgeting,
5621 5 => Self::RootComplexLinkDeclaration,
5622 6 => Self::RootComplexInternalLinkControl,
5623 7 => Self::RootComplexEventCollectorEndpointAssociation,
5624 8 => Self::MultiFunctionVirtualChannel,
5625 9 => Self::VirtualChannel,
5626 10 => Self::Rcrb,
5627 11 => Self::Vendor,
5628 12 => Self::Cac,
5629 13 => Self::Acs,
5630 14 => Self::Ari,
5631 15 => Self::Ats,
5632 16 => Self::SrIov,
5633 17 => Self::MrIov,
5634 18 => Self::Multicast,
5635 19 => Self::Pri,
5636 20 => Self::EnhancedAllocation,
5637 21 => Self::ResizableBar,
5638 22 => Self::DynamicPowerAllocation,
5639 23 => Self::Tph,
5640 24 => Self::LatencyToleranceReporting,
5641 25 => Self::SecondaryPciExpress,
5642 26 => Self::Pmux,
5643 27 => Self::Pasid,
5644 28 => Self::Lnr,
5645 29 => Self::Dpc,
5646 30 => Self::L1PmSubstates,
5647 31 => Self::PrecisionTimeMeasurement,
5648 32 => Self::Mpcie,
5649 33 => Self::FrsQueueing,
5650 34 => Self::ReadinessTimeReporting,
5651 35 => Self::DesignatedVendor,
5652 36 => Self::VfResizableBar,
5653 37 => Self::DataLinkFeature,
5654 38 => Self::PhysicalLayer16,
5655 39 => Self::LaneMarginingAtReceiver,
5656 40 => Self::HierarchyId,
5657 41 => Self::NativePcieEnclosure,
5658 42 => Self::PhysicalLayer32,
5659 43 => Self::AlternateProtocol,
5660 44 => Self::SystemFirmwareIntermediary,
5661
5662 _ => Self::UnknownOrdinal_(value),
5663 }
5664 }
5665 }
5666
5667 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
5668 for ExtendedCapabilityId
5669 where
5670 ___E: ?Sized,
5671 {
5672 #[inline]
5673 fn encode(
5674 self,
5675 encoder: &mut ___E,
5676 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
5677 _: (),
5678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5679 ::fidl_next::Encode::encode(&self, encoder, out, ())
5680 }
5681 }
5682
5683 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
5684 for &'a ExtendedCapabilityId
5685 where
5686 ___E: ?Sized,
5687 {
5688 #[inline]
5689 fn encode(
5690 self,
5691 encoder: &mut ___E,
5692 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
5693 _: (),
5694 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5695 ::fidl_next::munge!(let crate::wire::ExtendedCapabilityId { value } = out);
5696 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
5697 ExtendedCapabilityId::Null => 0,
5698
5699 ExtendedCapabilityId::AdvancedErrorReporting => 1,
5700
5701 ExtendedCapabilityId::VirtualChannelNoMfvc => 2,
5702
5703 ExtendedCapabilityId::DeviceSerialNumber => 3,
5704
5705 ExtendedCapabilityId::PowerBudgeting => 4,
5706
5707 ExtendedCapabilityId::RootComplexLinkDeclaration => 5,
5708
5709 ExtendedCapabilityId::RootComplexInternalLinkControl => 6,
5710
5711 ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => 7,
5712
5713 ExtendedCapabilityId::MultiFunctionVirtualChannel => 8,
5714
5715 ExtendedCapabilityId::VirtualChannel => 9,
5716
5717 ExtendedCapabilityId::Rcrb => 10,
5718
5719 ExtendedCapabilityId::Vendor => 11,
5720
5721 ExtendedCapabilityId::Cac => 12,
5722
5723 ExtendedCapabilityId::Acs => 13,
5724
5725 ExtendedCapabilityId::Ari => 14,
5726
5727 ExtendedCapabilityId::Ats => 15,
5728
5729 ExtendedCapabilityId::SrIov => 16,
5730
5731 ExtendedCapabilityId::MrIov => 17,
5732
5733 ExtendedCapabilityId::Multicast => 18,
5734
5735 ExtendedCapabilityId::Pri => 19,
5736
5737 ExtendedCapabilityId::EnhancedAllocation => 20,
5738
5739 ExtendedCapabilityId::ResizableBar => 21,
5740
5741 ExtendedCapabilityId::DynamicPowerAllocation => 22,
5742
5743 ExtendedCapabilityId::Tph => 23,
5744
5745 ExtendedCapabilityId::LatencyToleranceReporting => 24,
5746
5747 ExtendedCapabilityId::SecondaryPciExpress => 25,
5748
5749 ExtendedCapabilityId::Pmux => 26,
5750
5751 ExtendedCapabilityId::Pasid => 27,
5752
5753 ExtendedCapabilityId::Lnr => 28,
5754
5755 ExtendedCapabilityId::Dpc => 29,
5756
5757 ExtendedCapabilityId::L1PmSubstates => 30,
5758
5759 ExtendedCapabilityId::PrecisionTimeMeasurement => 31,
5760
5761 ExtendedCapabilityId::Mpcie => 32,
5762
5763 ExtendedCapabilityId::FrsQueueing => 33,
5764
5765 ExtendedCapabilityId::ReadinessTimeReporting => 34,
5766
5767 ExtendedCapabilityId::DesignatedVendor => 35,
5768
5769 ExtendedCapabilityId::VfResizableBar => 36,
5770
5771 ExtendedCapabilityId::DataLinkFeature => 37,
5772
5773 ExtendedCapabilityId::PhysicalLayer16 => 38,
5774
5775 ExtendedCapabilityId::LaneMarginingAtReceiver => 39,
5776
5777 ExtendedCapabilityId::HierarchyId => 40,
5778
5779 ExtendedCapabilityId::NativePcieEnclosure => 41,
5780
5781 ExtendedCapabilityId::PhysicalLayer32 => 42,
5782
5783 ExtendedCapabilityId::AlternateProtocol => 43,
5784
5785 ExtendedCapabilityId::SystemFirmwareIntermediary => 44,
5786
5787 ExtendedCapabilityId::UnknownOrdinal_(value) => value,
5788 }));
5789
5790 Ok(())
5791 }
5792 }
5793
5794 impl ::core::convert::From<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
5795 fn from(wire: crate::wire::ExtendedCapabilityId) -> Self {
5796 match u16::from(wire.value) {
5797 0 => Self::Null,
5798
5799 1 => Self::AdvancedErrorReporting,
5800
5801 2 => Self::VirtualChannelNoMfvc,
5802
5803 3 => Self::DeviceSerialNumber,
5804
5805 4 => Self::PowerBudgeting,
5806
5807 5 => Self::RootComplexLinkDeclaration,
5808
5809 6 => Self::RootComplexInternalLinkControl,
5810
5811 7 => Self::RootComplexEventCollectorEndpointAssociation,
5812
5813 8 => Self::MultiFunctionVirtualChannel,
5814
5815 9 => Self::VirtualChannel,
5816
5817 10 => Self::Rcrb,
5818
5819 11 => Self::Vendor,
5820
5821 12 => Self::Cac,
5822
5823 13 => Self::Acs,
5824
5825 14 => Self::Ari,
5826
5827 15 => Self::Ats,
5828
5829 16 => Self::SrIov,
5830
5831 17 => Self::MrIov,
5832
5833 18 => Self::Multicast,
5834
5835 19 => Self::Pri,
5836
5837 20 => Self::EnhancedAllocation,
5838
5839 21 => Self::ResizableBar,
5840
5841 22 => Self::DynamicPowerAllocation,
5842
5843 23 => Self::Tph,
5844
5845 24 => Self::LatencyToleranceReporting,
5846
5847 25 => Self::SecondaryPciExpress,
5848
5849 26 => Self::Pmux,
5850
5851 27 => Self::Pasid,
5852
5853 28 => Self::Lnr,
5854
5855 29 => Self::Dpc,
5856
5857 30 => Self::L1PmSubstates,
5858
5859 31 => Self::PrecisionTimeMeasurement,
5860
5861 32 => Self::Mpcie,
5862
5863 33 => Self::FrsQueueing,
5864
5865 34 => Self::ReadinessTimeReporting,
5866
5867 35 => Self::DesignatedVendor,
5868
5869 36 => Self::VfResizableBar,
5870
5871 37 => Self::DataLinkFeature,
5872
5873 38 => Self::PhysicalLayer16,
5874
5875 39 => Self::LaneMarginingAtReceiver,
5876
5877 40 => Self::HierarchyId,
5878
5879 41 => Self::NativePcieEnclosure,
5880
5881 42 => Self::PhysicalLayer32,
5882
5883 43 => Self::AlternateProtocol,
5884
5885 44 => Self::SystemFirmwareIntermediary,
5886
5887 value => Self::UnknownOrdinal_(value),
5888 }
5889 }
5890 }
5891
5892 impl ::fidl_next::FromWire<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
5893 #[inline]
5894 fn from_wire(wire: crate::wire::ExtendedCapabilityId) -> Self {
5895 Self::from(wire)
5896 }
5897 }
5898
5899 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
5900 #[inline]
5901 fn from_wire_ref(wire: &crate::wire::ExtendedCapabilityId) -> Self {
5902 Self::from(*wire)
5903 }
5904 }
5905
5906 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5907 #[repr(C)]
5908 pub struct DeviceGetExtendedCapabilitiesRequest {
5909 pub id: crate::natural::ExtendedCapabilityId,
5910 }
5911
5912 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
5913 for DeviceGetExtendedCapabilitiesRequest
5914 where
5915 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5916 {
5917 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5918 Self,
5919 crate::wire::DeviceGetExtendedCapabilitiesRequest,
5920 > = unsafe {
5921 ::fidl_next::CopyOptimization::enable_if(
5922 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::Encode<
5923 crate::wire::ExtendedCapabilityId,
5924 ___E,
5925 >>::COPY_OPTIMIZATION
5926 .is_enabled(),
5927 )
5928 };
5929
5930 #[inline]
5931 fn encode(
5932 self,
5933 encoder_: &mut ___E,
5934 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
5935 _: (),
5936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5937 ::fidl_next::munge! {
5938 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
5939 id,
5940
5941 } = out_;
5942 }
5943
5944 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5945
5946 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5947
5948 Ok(())
5949 }
5950 }
5951
5952 unsafe impl<'a, ___E>
5953 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
5954 for &'a DeviceGetExtendedCapabilitiesRequest
5955 where
5956 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5957 {
5958 #[inline]
5959 fn encode(
5960 self,
5961 encoder_: &mut ___E,
5962 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
5963 _: (),
5964 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5965 ::fidl_next::munge! {
5966 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
5967 id,
5968
5969 } = out_;
5970 }
5971
5972 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
5973
5974 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5975
5976 Ok(())
5977 }
5978 }
5979
5980 unsafe impl<___E>
5981 ::fidl_next::EncodeOption<
5982 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
5983 ___E,
5984 > for DeviceGetExtendedCapabilitiesRequest
5985 where
5986 ___E: ::fidl_next::Encoder + ?Sized,
5987 DeviceGetExtendedCapabilitiesRequest:
5988 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
5989 {
5990 #[inline]
5991 fn encode_option(
5992 this: ::core::option::Option<Self>,
5993 encoder: &mut ___E,
5994 out: &mut ::core::mem::MaybeUninit<
5995 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
5996 >,
5997 _: (),
5998 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5999 if let Some(inner) = this {
6000 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6001 ::fidl_next::wire::Box::encode_present(out);
6002 } else {
6003 ::fidl_next::wire::Box::encode_absent(out);
6004 }
6005
6006 Ok(())
6007 }
6008 }
6009
6010 unsafe impl<'a, ___E>
6011 ::fidl_next::EncodeOption<
6012 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6013 ___E,
6014 > for &'a DeviceGetExtendedCapabilitiesRequest
6015 where
6016 ___E: ::fidl_next::Encoder + ?Sized,
6017 &'a DeviceGetExtendedCapabilitiesRequest:
6018 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
6019 {
6020 #[inline]
6021 fn encode_option(
6022 this: ::core::option::Option<Self>,
6023 encoder: &mut ___E,
6024 out: &mut ::core::mem::MaybeUninit<
6025 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6026 >,
6027 _: (),
6028 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6029 if let Some(inner) = this {
6030 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6031 ::fidl_next::wire::Box::encode_present(out);
6032 } else {
6033 ::fidl_next::wire::Box::encode_absent(out);
6034 }
6035
6036 Ok(())
6037 }
6038 }
6039
6040 impl ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6041 for DeviceGetExtendedCapabilitiesRequest
6042 {
6043 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6044 crate::wire::DeviceGetExtendedCapabilitiesRequest,
6045 Self,
6046 > = unsafe {
6047 ::fidl_next::CopyOptimization::enable_if(
6048 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::FromWire<
6049 crate::wire::ExtendedCapabilityId,
6050 >>::COPY_OPTIMIZATION
6051 .is_enabled(),
6052 )
6053 };
6054
6055 #[inline]
6056 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6057 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
6058 }
6059 }
6060
6061 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6062 for DeviceGetExtendedCapabilitiesRequest
6063 {
6064 #[inline]
6065 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6066 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
6067 }
6068 }
6069
6070 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6071 pub struct DeviceGetExtendedCapabilitiesResponse {
6072 pub offsets: ::std::vec::Vec<u16>,
6073 }
6074
6075 unsafe impl<___E>
6076 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6077 for DeviceGetExtendedCapabilitiesResponse
6078 where
6079 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6080 ___E: ::fidl_next::Encoder,
6081 {
6082 #[inline]
6083 fn encode(
6084 self,
6085 encoder_: &mut ___E,
6086 out_: &mut ::core::mem::MaybeUninit<
6087 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6088 >,
6089 _: (),
6090 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6091 ::fidl_next::munge! {
6092 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6093 offsets,
6094
6095 } = out_;
6096 }
6097
6098 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
6099
6100 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6101 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6102
6103 Ok(())
6104 }
6105 }
6106
6107 unsafe impl<'a, ___E>
6108 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6109 for &'a DeviceGetExtendedCapabilitiesResponse
6110 where
6111 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6112 ___E: ::fidl_next::Encoder,
6113 {
6114 #[inline]
6115 fn encode(
6116 self,
6117 encoder_: &mut ___E,
6118 out_: &mut ::core::mem::MaybeUninit<
6119 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6120 >,
6121 _: (),
6122 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6123 ::fidl_next::munge! {
6124 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6125 offsets,
6126
6127 } = out_;
6128 }
6129
6130 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
6131
6132 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6133 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6134
6135 Ok(())
6136 }
6137 }
6138
6139 unsafe impl<___E>
6140 ::fidl_next::EncodeOption<
6141 ::fidl_next::wire::Box<
6142 'static,
6143 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6144 >,
6145 ___E,
6146 > for DeviceGetExtendedCapabilitiesResponse
6147 where
6148 ___E: ::fidl_next::Encoder + ?Sized,
6149 DeviceGetExtendedCapabilitiesResponse:
6150 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6151 {
6152 #[inline]
6153 fn encode_option(
6154 this: ::core::option::Option<Self>,
6155 encoder: &mut ___E,
6156 out: &mut ::core::mem::MaybeUninit<
6157 ::fidl_next::wire::Box<
6158 'static,
6159 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6160 >,
6161 >,
6162 _: (),
6163 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6164 if let Some(inner) = this {
6165 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6166 ::fidl_next::wire::Box::encode_present(out);
6167 } else {
6168 ::fidl_next::wire::Box::encode_absent(out);
6169 }
6170
6171 Ok(())
6172 }
6173 }
6174
6175 unsafe impl<'a, ___E>
6176 ::fidl_next::EncodeOption<
6177 ::fidl_next::wire::Box<
6178 'static,
6179 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6180 >,
6181 ___E,
6182 > for &'a DeviceGetExtendedCapabilitiesResponse
6183 where
6184 ___E: ::fidl_next::Encoder + ?Sized,
6185 &'a DeviceGetExtendedCapabilitiesResponse:
6186 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6187 {
6188 #[inline]
6189 fn encode_option(
6190 this: ::core::option::Option<Self>,
6191 encoder: &mut ___E,
6192 out: &mut ::core::mem::MaybeUninit<
6193 ::fidl_next::wire::Box<
6194 'static,
6195 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6196 >,
6197 >,
6198 _: (),
6199 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6200 if let Some(inner) = this {
6201 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6202 ::fidl_next::wire::Box::encode_present(out);
6203 } else {
6204 ::fidl_next::wire::Box::encode_absent(out);
6205 }
6206
6207 Ok(())
6208 }
6209 }
6210
6211 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6212 for DeviceGetExtendedCapabilitiesResponse
6213 {
6214 #[inline]
6215 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6216 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
6217 }
6218 }
6219
6220 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6221 for DeviceGetExtendedCapabilitiesResponse
6222 {
6223 #[inline]
6224 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6225 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
6226 }
6227 }
6228
6229 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6230 #[repr(C)]
6231 pub struct DeviceGetBtiRequest {
6232 pub index: u32,
6233 }
6234
6235 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6236 for DeviceGetBtiRequest
6237 where
6238 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6239 {
6240 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6241 Self,
6242 crate::wire::DeviceGetBtiRequest,
6243 > = unsafe {
6244 ::fidl_next::CopyOptimization::enable_if(
6245 true
6246
6247 && <
6248 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
6249 >::COPY_OPTIMIZATION.is_enabled()
6250
6251 )
6252 };
6253
6254 #[inline]
6255 fn encode(
6256 self,
6257 encoder_: &mut ___E,
6258 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6259 _: (),
6260 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6261 ::fidl_next::munge! {
6262 let crate::wire::DeviceGetBtiRequest {
6263 index,
6264
6265 } = out_;
6266 }
6267
6268 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
6269
6270 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6271
6272 Ok(())
6273 }
6274 }
6275
6276 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6277 for &'a DeviceGetBtiRequest
6278 where
6279 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6280 {
6281 #[inline]
6282 fn encode(
6283 self,
6284 encoder_: &mut ___E,
6285 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6286 _: (),
6287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6288 ::fidl_next::munge! {
6289 let crate::wire::DeviceGetBtiRequest {
6290 index,
6291
6292 } = out_;
6293 }
6294
6295 ::fidl_next::Encode::encode(&self.index, encoder_, index, ())?;
6296
6297 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6298
6299 Ok(())
6300 }
6301 }
6302
6303 unsafe impl<___E>
6304 ::fidl_next::EncodeOption<
6305 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6306 ___E,
6307 > for DeviceGetBtiRequest
6308 where
6309 ___E: ::fidl_next::Encoder + ?Sized,
6310 DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6311 {
6312 #[inline]
6313 fn encode_option(
6314 this: ::core::option::Option<Self>,
6315 encoder: &mut ___E,
6316 out: &mut ::core::mem::MaybeUninit<
6317 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6318 >,
6319 _: (),
6320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6321 if let Some(inner) = this {
6322 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6323 ::fidl_next::wire::Box::encode_present(out);
6324 } else {
6325 ::fidl_next::wire::Box::encode_absent(out);
6326 }
6327
6328 Ok(())
6329 }
6330 }
6331
6332 unsafe impl<'a, ___E>
6333 ::fidl_next::EncodeOption<
6334 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6335 ___E,
6336 > for &'a DeviceGetBtiRequest
6337 where
6338 ___E: ::fidl_next::Encoder + ?Sized,
6339 &'a DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6340 {
6341 #[inline]
6342 fn encode_option(
6343 this: ::core::option::Option<Self>,
6344 encoder: &mut ___E,
6345 out: &mut ::core::mem::MaybeUninit<
6346 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6347 >,
6348 _: (),
6349 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6350 if let Some(inner) = this {
6351 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6352 ::fidl_next::wire::Box::encode_present(out);
6353 } else {
6354 ::fidl_next::wire::Box::encode_absent(out);
6355 }
6356
6357 Ok(())
6358 }
6359 }
6360
6361 impl ::fidl_next::FromWire<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
6362 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6363 crate::wire::DeviceGetBtiRequest,
6364 Self,
6365 > = unsafe {
6366 ::fidl_next::CopyOptimization::enable_if(
6367 true
6368 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
6369 .is_enabled(),
6370 )
6371 };
6372
6373 #[inline]
6374 fn from_wire(wire: crate::wire::DeviceGetBtiRequest) -> Self {
6375 Self { index: ::fidl_next::FromWire::from_wire(wire.index) }
6376 }
6377 }
6378
6379 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
6380 #[inline]
6381 fn from_wire_ref(wire: &crate::wire::DeviceGetBtiRequest) -> Self {
6382 Self { index: ::fidl_next::FromWireRef::from_wire_ref(&wire.index) }
6383 }
6384 }
6385
6386 #[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"]
6387 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6388 #[repr(u8)]
6389 pub enum InterruptMode {
6390 Disabled = 0,
6391 Legacy = 1,
6392 LegacyNoack = 2,
6393 Msi = 3,
6394 MsiX = 4,
6395 UnknownOrdinal_(u8) = 5,
6396 }
6397 impl ::std::convert::From<u8> for InterruptMode {
6398 fn from(value: u8) -> Self {
6399 match value {
6400 0 => Self::Disabled,
6401 1 => Self::Legacy,
6402 2 => Self::LegacyNoack,
6403 3 => Self::Msi,
6404 4 => Self::MsiX,
6405
6406 _ => Self::UnknownOrdinal_(value),
6407 }
6408 }
6409 }
6410
6411 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for InterruptMode
6412 where
6413 ___E: ?Sized,
6414 {
6415 #[inline]
6416 fn encode(
6417 self,
6418 encoder: &mut ___E,
6419 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
6420 _: (),
6421 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6422 ::fidl_next::Encode::encode(&self, encoder, out, ())
6423 }
6424 }
6425
6426 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for &'a InterruptMode
6427 where
6428 ___E: ?Sized,
6429 {
6430 #[inline]
6431 fn encode(
6432 self,
6433 encoder: &mut ___E,
6434 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
6435 _: (),
6436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6437 ::fidl_next::munge!(let crate::wire::InterruptMode { value } = out);
6438 let _ = value.write(u8::from(match *self {
6439 InterruptMode::Disabled => 0,
6440
6441 InterruptMode::Legacy => 1,
6442
6443 InterruptMode::LegacyNoack => 2,
6444
6445 InterruptMode::Msi => 3,
6446
6447 InterruptMode::MsiX => 4,
6448
6449 InterruptMode::UnknownOrdinal_(value) => value,
6450 }));
6451
6452 Ok(())
6453 }
6454 }
6455
6456 impl ::core::convert::From<crate::wire::InterruptMode> for InterruptMode {
6457 fn from(wire: crate::wire::InterruptMode) -> Self {
6458 match u8::from(wire.value) {
6459 0 => Self::Disabled,
6460
6461 1 => Self::Legacy,
6462
6463 2 => Self::LegacyNoack,
6464
6465 3 => Self::Msi,
6466
6467 4 => Self::MsiX,
6468
6469 value => Self::UnknownOrdinal_(value),
6470 }
6471 }
6472 }
6473
6474 impl ::fidl_next::FromWire<crate::wire::InterruptMode> for InterruptMode {
6475 #[inline]
6476 fn from_wire(wire: crate::wire::InterruptMode) -> Self {
6477 Self::from(wire)
6478 }
6479 }
6480
6481 impl ::fidl_next::FromWireRef<crate::wire::InterruptMode> for InterruptMode {
6482 #[inline]
6483 fn from_wire_ref(wire: &crate::wire::InterruptMode) -> Self {
6484 Self::from(*wire)
6485 }
6486 }
6487
6488 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6489 pub struct DeviceSetInterruptModeRequest {
6490 pub mode: crate::natural::InterruptMode,
6491
6492 pub requested_irq_count: u32,
6493 }
6494
6495 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
6496 for DeviceSetInterruptModeRequest
6497 where
6498 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6499 {
6500 #[inline]
6501 fn encode(
6502 self,
6503 encoder_: &mut ___E,
6504 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
6505 _: (),
6506 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6507 ::fidl_next::munge! {
6508 let crate::wire::DeviceSetInterruptModeRequest {
6509 mode,
6510 requested_irq_count,
6511
6512 } = out_;
6513 }
6514
6515 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
6516
6517 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
6518
6519 ::fidl_next::Encode::encode(
6520 self.requested_irq_count,
6521 encoder_,
6522 requested_irq_count,
6523 (),
6524 )?;
6525
6526 let mut _field =
6527 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
6528
6529 Ok(())
6530 }
6531 }
6532
6533 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
6534 for &'a DeviceSetInterruptModeRequest
6535 where
6536 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6537 {
6538 #[inline]
6539 fn encode(
6540 self,
6541 encoder_: &mut ___E,
6542 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
6543 _: (),
6544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6545 ::fidl_next::munge! {
6546 let crate::wire::DeviceSetInterruptModeRequest {
6547 mode,
6548 requested_irq_count,
6549
6550 } = out_;
6551 }
6552
6553 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
6554
6555 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
6556
6557 ::fidl_next::Encode::encode(
6558 &self.requested_irq_count,
6559 encoder_,
6560 requested_irq_count,
6561 (),
6562 )?;
6563
6564 let mut _field =
6565 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
6566
6567 Ok(())
6568 }
6569 }
6570
6571 unsafe impl<___E>
6572 ::fidl_next::EncodeOption<
6573 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6574 ___E,
6575 > for DeviceSetInterruptModeRequest
6576 where
6577 ___E: ::fidl_next::Encoder + ?Sized,
6578 DeviceSetInterruptModeRequest:
6579 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
6580 {
6581 #[inline]
6582 fn encode_option(
6583 this: ::core::option::Option<Self>,
6584 encoder: &mut ___E,
6585 out: &mut ::core::mem::MaybeUninit<
6586 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6587 >,
6588 _: (),
6589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6590 if let Some(inner) = this {
6591 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6592 ::fidl_next::wire::Box::encode_present(out);
6593 } else {
6594 ::fidl_next::wire::Box::encode_absent(out);
6595 }
6596
6597 Ok(())
6598 }
6599 }
6600
6601 unsafe impl<'a, ___E>
6602 ::fidl_next::EncodeOption<
6603 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6604 ___E,
6605 > for &'a DeviceSetInterruptModeRequest
6606 where
6607 ___E: ::fidl_next::Encoder + ?Sized,
6608 &'a DeviceSetInterruptModeRequest:
6609 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
6610 {
6611 #[inline]
6612 fn encode_option(
6613 this: ::core::option::Option<Self>,
6614 encoder: &mut ___E,
6615 out: &mut ::core::mem::MaybeUninit<
6616 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
6617 >,
6618 _: (),
6619 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6620 if let Some(inner) = this {
6621 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6622 ::fidl_next::wire::Box::encode_present(out);
6623 } else {
6624 ::fidl_next::wire::Box::encode_absent(out);
6625 }
6626
6627 Ok(())
6628 }
6629 }
6630
6631 impl ::fidl_next::FromWire<crate::wire::DeviceSetInterruptModeRequest>
6632 for DeviceSetInterruptModeRequest
6633 {
6634 #[inline]
6635 fn from_wire(wire: crate::wire::DeviceSetInterruptModeRequest) -> Self {
6636 Self {
6637 mode: ::fidl_next::FromWire::from_wire(wire.mode),
6638
6639 requested_irq_count: ::fidl_next::FromWire::from_wire(wire.requested_irq_count),
6640 }
6641 }
6642 }
6643
6644 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetInterruptModeRequest>
6645 for DeviceSetInterruptModeRequest
6646 {
6647 #[inline]
6648 fn from_wire_ref(wire: &crate::wire::DeviceSetInterruptModeRequest) -> Self {
6649 Self {
6650 mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
6651
6652 requested_irq_count: ::fidl_next::FromWireRef::from_wire_ref(
6653 &wire.requested_irq_count,
6654 ),
6655 }
6656 }
6657 }
6658
6659 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6660 #[repr(u8)]
6661 pub enum HeaderType {
6662 Standard = 0,
6663 Bridge = 1,
6664 CardBus = 2,
6665 Mask = 127,
6666 MultiFn = 128,
6667 UnknownOrdinal_(u8) = 129,
6668 }
6669 impl ::std::convert::From<u8> for HeaderType {
6670 fn from(value: u8) -> Self {
6671 match value {
6672 0 => Self::Standard,
6673 1 => Self::Bridge,
6674 2 => Self::CardBus,
6675 127 => Self::Mask,
6676 128 => Self::MultiFn,
6677
6678 _ => Self::UnknownOrdinal_(value),
6679 }
6680 }
6681 }
6682
6683 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for HeaderType
6684 where
6685 ___E: ?Sized,
6686 {
6687 #[inline]
6688 fn encode(
6689 self,
6690 encoder: &mut ___E,
6691 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
6692 _: (),
6693 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6694 ::fidl_next::Encode::encode(&self, encoder, out, ())
6695 }
6696 }
6697
6698 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for &'a HeaderType
6699 where
6700 ___E: ?Sized,
6701 {
6702 #[inline]
6703 fn encode(
6704 self,
6705 encoder: &mut ___E,
6706 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
6707 _: (),
6708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6709 ::fidl_next::munge!(let crate::wire::HeaderType { value } = out);
6710 let _ = value.write(u8::from(match *self {
6711 HeaderType::Standard => 0,
6712
6713 HeaderType::Bridge => 1,
6714
6715 HeaderType::CardBus => 2,
6716
6717 HeaderType::Mask => 127,
6718
6719 HeaderType::MultiFn => 128,
6720
6721 HeaderType::UnknownOrdinal_(value) => value,
6722 }));
6723
6724 Ok(())
6725 }
6726 }
6727
6728 impl ::core::convert::From<crate::wire::HeaderType> for HeaderType {
6729 fn from(wire: crate::wire::HeaderType) -> Self {
6730 match u8::from(wire.value) {
6731 0 => Self::Standard,
6732
6733 1 => Self::Bridge,
6734
6735 2 => Self::CardBus,
6736
6737 127 => Self::Mask,
6738
6739 128 => Self::MultiFn,
6740
6741 value => Self::UnknownOrdinal_(value),
6742 }
6743 }
6744 }
6745
6746 impl ::fidl_next::FromWire<crate::wire::HeaderType> for HeaderType {
6747 #[inline]
6748 fn from_wire(wire: crate::wire::HeaderType) -> Self {
6749 Self::from(wire)
6750 }
6751 }
6752
6753 impl ::fidl_next::FromWireRef<crate::wire::HeaderType> for HeaderType {
6754 #[inline]
6755 fn from_wire_ref(wire: &crate::wire::HeaderType) -> Self {
6756 Self::from(*wire)
6757 }
6758 }
6759
6760 ::fidl_next::bitflags::bitflags! {
6761 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Status: u16 {
6762 const INTERRUPT = 8;
6763 const NEW_CAPS = 16;
6764 const SIXTYSIX_MHZ = 32;
6765 const FAST_B2_B = 128;
6766 const MSTR_PERR = 256;
6767 const DEVSEL_LOW = 512;
6768 const DEVSEL_HIGH = 1024;
6769 const TARG_ABORT_SIG = 2048;
6770 const TARG_ABORT_RCV = 4096;
6771 const MSTR_ABORT_RCV = 8192;
6772 const SERR_SIG = 16384;
6773 const PERR = 32768;
6774 const _ = !0;
6775 }
6776 }
6777
6778 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Status, ___E> for Status
6779 where
6780 ___E: ?Sized,
6781 {
6782 #[inline]
6783 fn encode(
6784 self,
6785 encoder: &mut ___E,
6786 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
6787 _: (),
6788 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6789 ::fidl_next::Encode::encode(&self, encoder, out, ())
6790 }
6791 }
6792
6793 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Status, ___E> for &'a Status
6794 where
6795 ___E: ?Sized,
6796 {
6797 #[inline]
6798 fn encode(
6799 self,
6800 _: &mut ___E,
6801 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
6802 _: (),
6803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6804 ::fidl_next::munge!(let crate::wire::Status { value } = out);
6805
6806 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
6807 Ok(())
6808 }
6809 }
6810
6811 impl ::core::convert::From<crate::wire::Status> for Status {
6812 fn from(wire: crate::wire::Status) -> Self {
6813 Self::from_bits_retain(u16::from(wire.value))
6814 }
6815 }
6816
6817 impl ::fidl_next::FromWire<crate::wire::Status> for Status {
6818 #[inline]
6819 fn from_wire(wire: crate::wire::Status) -> Self {
6820 Self::from(wire)
6821 }
6822 }
6823
6824 impl ::fidl_next::FromWireRef<crate::wire::Status> for Status {
6825 #[inline]
6826 fn from_wire_ref(wire: &crate::wire::Status) -> Self {
6827 Self::from(*wire)
6828 }
6829 }
6830}
6831
6832pub mod wire {
6833
6834 #[derive(Clone, Debug)]
6836 #[repr(C)]
6837 pub struct Address {
6838 pub bus: u8,
6839
6840 pub device: u8,
6841
6842 pub function: u8,
6843 }
6844
6845 static_assertions::const_assert_eq!(std::mem::size_of::<Address>(), 3);
6846 static_assertions::const_assert_eq!(std::mem::align_of::<Address>(), 1);
6847
6848 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, bus), 0);
6849
6850 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, device), 1);
6851
6852 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, function), 2);
6853
6854 impl ::fidl_next::Constrained for Address {
6855 type Constraint = ();
6856
6857 fn validate(
6858 _: ::fidl_next::Slot<'_, Self>,
6859 _: Self::Constraint,
6860 ) -> Result<(), ::fidl_next::ValidationError> {
6861 Ok(())
6862 }
6863 }
6864
6865 unsafe impl ::fidl_next::Wire for Address {
6866 type Narrowed<'de> = Address;
6867
6868 #[inline]
6869 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6870 ::fidl_next::munge! {
6871 let Self {
6872 bus,
6873 device,
6874 function,
6875
6876 } = &mut *out_;
6877 }
6878
6879 ::fidl_next::Wire::zero_padding(bus);
6880
6881 ::fidl_next::Wire::zero_padding(device);
6882
6883 ::fidl_next::Wire::zero_padding(function);
6884 }
6885 }
6886
6887 unsafe impl<___D> ::fidl_next::Decode<___D> for Address
6888 where
6889 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6890 {
6891 fn decode(
6892 slot_: ::fidl_next::Slot<'_, Self>,
6893 decoder_: &mut ___D,
6894 _: (),
6895 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6896 ::fidl_next::munge! {
6897 let Self {
6898 mut bus,
6899 mut device,
6900 mut function,
6901
6902 } = slot_;
6903 }
6904
6905 let _field = bus.as_mut();
6906
6907 ::fidl_next::Decode::decode(bus.as_mut(), decoder_, ())?;
6908
6909 let _field = device.as_mut();
6910
6911 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
6912
6913 let _field = function.as_mut();
6914
6915 ::fidl_next::Decode::decode(function.as_mut(), decoder_, ())?;
6916
6917 Ok(())
6918 }
6919 }
6920
6921 impl ::fidl_next::IntoNatural for Address {
6922 type Natural = crate::natural::Address;
6923 }
6924
6925 #[derive(Clone, Debug)]
6927 #[repr(C)]
6928 pub struct BaseAddress {
6929 pub address: ::fidl_next::wire::Uint64,
6930
6931 pub size: ::fidl_next::wire::Uint64,
6932
6933 pub is_memory: bool,
6934
6935 pub is_prefetchable: bool,
6936
6937 pub is_64bit: bool,
6938
6939 pub id: u8,
6940 }
6941
6942 static_assertions::const_assert_eq!(std::mem::size_of::<BaseAddress>(), 24);
6943 static_assertions::const_assert_eq!(std::mem::align_of::<BaseAddress>(), 8);
6944
6945 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, address), 0);
6946
6947 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, size), 8);
6948
6949 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_memory), 16);
6950
6951 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_prefetchable), 17);
6952
6953 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_64bit), 18);
6954
6955 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, id), 19);
6956
6957 impl ::fidl_next::Constrained for BaseAddress {
6958 type Constraint = ();
6959
6960 fn validate(
6961 _: ::fidl_next::Slot<'_, Self>,
6962 _: Self::Constraint,
6963 ) -> Result<(), ::fidl_next::ValidationError> {
6964 Ok(())
6965 }
6966 }
6967
6968 unsafe impl ::fidl_next::Wire for BaseAddress {
6969 type Narrowed<'de> = BaseAddress;
6970
6971 #[inline]
6972 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6973 ::fidl_next::munge! {
6974 let Self {
6975 address,
6976 size,
6977 is_memory,
6978 is_prefetchable,
6979 is_64bit,
6980 id,
6981
6982 } = &mut *out_;
6983 }
6984
6985 ::fidl_next::Wire::zero_padding(address);
6986
6987 ::fidl_next::Wire::zero_padding(size);
6988
6989 ::fidl_next::Wire::zero_padding(is_memory);
6990
6991 ::fidl_next::Wire::zero_padding(is_prefetchable);
6992
6993 ::fidl_next::Wire::zero_padding(is_64bit);
6994
6995 ::fidl_next::Wire::zero_padding(id);
6996
6997 unsafe {
6998 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6999 }
7000 }
7001 }
7002
7003 unsafe impl<___D> ::fidl_next::Decode<___D> for BaseAddress
7004 where
7005 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7006 {
7007 fn decode(
7008 slot_: ::fidl_next::Slot<'_, Self>,
7009 decoder_: &mut ___D,
7010 _: (),
7011 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7012 if slot_.as_bytes()[20..24] != [0u8; 4] {
7013 return Err(::fidl_next::DecodeError::InvalidPadding);
7014 }
7015
7016 ::fidl_next::munge! {
7017 let Self {
7018 mut address,
7019 mut size,
7020 mut is_memory,
7021 mut is_prefetchable,
7022 mut is_64bit,
7023 mut id,
7024
7025 } = slot_;
7026 }
7027
7028 let _field = address.as_mut();
7029
7030 ::fidl_next::Decode::decode(address.as_mut(), decoder_, ())?;
7031
7032 let _field = size.as_mut();
7033
7034 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
7035
7036 let _field = is_memory.as_mut();
7037
7038 ::fidl_next::Decode::decode(is_memory.as_mut(), decoder_, ())?;
7039
7040 let _field = is_prefetchable.as_mut();
7041
7042 ::fidl_next::Decode::decode(is_prefetchable.as_mut(), decoder_, ())?;
7043
7044 let _field = is_64bit.as_mut();
7045
7046 ::fidl_next::Decode::decode(is_64bit.as_mut(), decoder_, ())?;
7047
7048 let _field = id.as_mut();
7049
7050 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7051
7052 Ok(())
7053 }
7054 }
7055
7056 impl ::fidl_next::IntoNatural for BaseAddress {
7057 type Natural = crate::natural::BaseAddress;
7058 }
7059
7060 pub type UseIntxWorkaroundType = ::fidl_next::wire::Unit;
7062
7063 #[repr(C)]
7065 pub struct BoardConfiguration<'de> {
7066 pub(crate) table: ::fidl_next::wire::Table<'de>,
7067 }
7068
7069 impl<'de> Drop for BoardConfiguration<'de> {
7070 fn drop(&mut self) {
7071 let _ = self.table.get(1).map(|envelope| unsafe {
7072 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
7073 });
7074 }
7075 }
7076
7077 impl ::fidl_next::Constrained for BoardConfiguration<'_> {
7078 type Constraint = ();
7079
7080 fn validate(
7081 _: ::fidl_next::Slot<'_, Self>,
7082 _: Self::Constraint,
7083 ) -> Result<(), ::fidl_next::ValidationError> {
7084 Ok(())
7085 }
7086 }
7087
7088 unsafe impl ::fidl_next::Wire for BoardConfiguration<'static> {
7089 type Narrowed<'de> = BoardConfiguration<'de>;
7090
7091 #[inline]
7092 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7093 ::fidl_next::munge!(let Self { table } = out);
7094 ::fidl_next::wire::Table::zero_padding(table);
7095 }
7096 }
7097
7098 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BoardConfiguration<'de>
7099 where
7100 ___D: ::fidl_next::Decoder<'de> + ?Sized,
7101 {
7102 fn decode(
7103 slot: ::fidl_next::Slot<'_, Self>,
7104 decoder: &mut ___D,
7105 _: (),
7106 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7107 ::fidl_next::munge!(let Self { table } = slot);
7108
7109 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
7110 match ordinal {
7111 0 => unsafe { ::core::hint::unreachable_unchecked() },
7112
7113 1 => {
7114 ::fidl_next::wire::Envelope::decode_as::<
7115 ___D,
7116 crate::wire::UseIntxWorkaroundType,
7117 >(slot.as_mut(), decoder, ())?;
7118
7119 Ok(())
7120 }
7121
7122 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
7123 }
7124 })
7125 }
7126 }
7127
7128 impl<'de> BoardConfiguration<'de> {
7129 pub fn use_intx_workaround(
7130 &self,
7131 ) -> ::core::option::Option<&crate::wire::UseIntxWorkaroundType> {
7132 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
7133 }
7134 }
7135
7136 impl<'de> ::core::fmt::Debug for BoardConfiguration<'de> {
7137 fn fmt(
7138 &self,
7139 f: &mut ::core::fmt::Formatter<'_>,
7140 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7141 f.debug_struct("BoardConfiguration")
7142 .field("use_intx_workaround", &self.use_intx_workaround())
7143 .finish()
7144 }
7145 }
7146
7147 impl<'de> ::fidl_next::IntoNatural for BoardConfiguration<'de> {
7148 type Natural = crate::natural::BoardConfiguration;
7149 }
7150
7151 #[derive(Debug)]
7153 #[repr(C)]
7154 pub struct HostBridgeInfo<'de> {
7155 pub name: ::fidl_next::wire::String<'de>,
7156
7157 pub start_bus_number: u8,
7158
7159 pub end_bus_number: u8,
7160
7161 pub segment_group: ::fidl_next::wire::Uint16,
7162 }
7163
7164 static_assertions::const_assert_eq!(std::mem::size_of::<HostBridgeInfo<'_>>(), 24);
7165 static_assertions::const_assert_eq!(std::mem::align_of::<HostBridgeInfo<'_>>(), 8);
7166
7167 static_assertions::const_assert_eq!(std::mem::offset_of!(HostBridgeInfo<'_>, name), 0);
7168
7169 static_assertions::const_assert_eq!(
7170 std::mem::offset_of!(HostBridgeInfo<'_>, start_bus_number),
7171 16
7172 );
7173
7174 static_assertions::const_assert_eq!(
7175 std::mem::offset_of!(HostBridgeInfo<'_>, end_bus_number),
7176 17
7177 );
7178
7179 static_assertions::const_assert_eq!(
7180 std::mem::offset_of!(HostBridgeInfo<'_>, segment_group),
7181 18
7182 );
7183
7184 impl ::fidl_next::Constrained for HostBridgeInfo<'_> {
7185 type Constraint = ();
7186
7187 fn validate(
7188 _: ::fidl_next::Slot<'_, Self>,
7189 _: Self::Constraint,
7190 ) -> Result<(), ::fidl_next::ValidationError> {
7191 Ok(())
7192 }
7193 }
7194
7195 unsafe impl ::fidl_next::Wire for HostBridgeInfo<'static> {
7196 type Narrowed<'de> = HostBridgeInfo<'de>;
7197
7198 #[inline]
7199 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7200 ::fidl_next::munge! {
7201 let Self {
7202 name,
7203 start_bus_number,
7204 end_bus_number,
7205 segment_group,
7206
7207 } = &mut *out_;
7208 }
7209
7210 ::fidl_next::Wire::zero_padding(name);
7211
7212 ::fidl_next::Wire::zero_padding(start_bus_number);
7213
7214 ::fidl_next::Wire::zero_padding(end_bus_number);
7215
7216 ::fidl_next::Wire::zero_padding(segment_group);
7217
7218 unsafe {
7219 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
7220 }
7221 }
7222 }
7223
7224 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for HostBridgeInfo<'de>
7225 where
7226 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7227 ___D: ::fidl_next::Decoder<'de>,
7228 {
7229 fn decode(
7230 slot_: ::fidl_next::Slot<'_, Self>,
7231 decoder_: &mut ___D,
7232 _: (),
7233 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7234 if slot_.as_bytes()[20..24] != [0u8; 4] {
7235 return Err(::fidl_next::DecodeError::InvalidPadding);
7236 }
7237
7238 ::fidl_next::munge! {
7239 let Self {
7240 mut name,
7241 mut start_bus_number,
7242 mut end_bus_number,
7243 mut segment_group,
7244
7245 } = slot_;
7246 }
7247
7248 let _field = name.as_mut();
7249 ::fidl_next::Constrained::validate(_field, 32)?;
7250 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 32)?;
7251
7252 let name = unsafe { name.deref_unchecked() };
7253
7254 if name.len() > 32 {
7255 return Err(::fidl_next::DecodeError::VectorTooLong {
7256 size: name.len() as u64,
7257 limit: 32,
7258 });
7259 }
7260
7261 let _field = start_bus_number.as_mut();
7262
7263 ::fidl_next::Decode::decode(start_bus_number.as_mut(), decoder_, ())?;
7264
7265 let _field = end_bus_number.as_mut();
7266
7267 ::fidl_next::Decode::decode(end_bus_number.as_mut(), decoder_, ())?;
7268
7269 let _field = segment_group.as_mut();
7270
7271 ::fidl_next::Decode::decode(segment_group.as_mut(), decoder_, ())?;
7272
7273 Ok(())
7274 }
7275 }
7276
7277 impl<'de> ::fidl_next::IntoNatural for HostBridgeInfo<'de> {
7278 type Natural = crate::natural::HostBridgeInfo;
7279 }
7280
7281 #[derive(Debug)]
7283 #[repr(C)]
7284 pub struct BusGetHostBridgeInfoResponse<'de> {
7285 pub info: crate::wire::HostBridgeInfo<'de>,
7286 }
7287
7288 static_assertions::const_assert_eq!(
7289 std::mem::size_of::<BusGetHostBridgeInfoResponse<'_>>(),
7290 24
7291 );
7292 static_assertions::const_assert_eq!(
7293 std::mem::align_of::<BusGetHostBridgeInfoResponse<'_>>(),
7294 8
7295 );
7296
7297 static_assertions::const_assert_eq!(
7298 std::mem::offset_of!(BusGetHostBridgeInfoResponse<'_>, info),
7299 0
7300 );
7301
7302 impl ::fidl_next::Constrained for BusGetHostBridgeInfoResponse<'_> {
7303 type Constraint = ();
7304
7305 fn validate(
7306 _: ::fidl_next::Slot<'_, Self>,
7307 _: Self::Constraint,
7308 ) -> Result<(), ::fidl_next::ValidationError> {
7309 Ok(())
7310 }
7311 }
7312
7313 unsafe impl ::fidl_next::Wire for BusGetHostBridgeInfoResponse<'static> {
7314 type Narrowed<'de> = BusGetHostBridgeInfoResponse<'de>;
7315
7316 #[inline]
7317 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7318 ::fidl_next::munge! {
7319 let Self {
7320 info,
7321
7322 } = &mut *out_;
7323 }
7324
7325 ::fidl_next::Wire::zero_padding(info);
7326 }
7327 }
7328
7329 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetHostBridgeInfoResponse<'de>
7330 where
7331 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7332 ___D: ::fidl_next::Decoder<'de>,
7333 {
7334 fn decode(
7335 slot_: ::fidl_next::Slot<'_, Self>,
7336 decoder_: &mut ___D,
7337 _: (),
7338 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7339 ::fidl_next::munge! {
7340 let Self {
7341 mut info,
7342
7343 } = slot_;
7344 }
7345
7346 let _field = info.as_mut();
7347
7348 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
7349
7350 Ok(())
7351 }
7352 }
7353
7354 impl<'de> ::fidl_next::IntoNatural for BusGetHostBridgeInfoResponse<'de> {
7355 type Natural = crate::natural::BusGetHostBridgeInfoResponse;
7356 }
7357
7358 #[derive(Clone, Debug)]
7360 #[repr(C)]
7361 pub struct Capability {
7362 pub id: u8,
7363
7364 pub offset: u8,
7365 }
7366
7367 static_assertions::const_assert_eq!(std::mem::size_of::<Capability>(), 2);
7368 static_assertions::const_assert_eq!(std::mem::align_of::<Capability>(), 1);
7369
7370 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, id), 0);
7371
7372 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, offset), 1);
7373
7374 impl ::fidl_next::Constrained for Capability {
7375 type Constraint = ();
7376
7377 fn validate(
7378 _: ::fidl_next::Slot<'_, Self>,
7379 _: Self::Constraint,
7380 ) -> Result<(), ::fidl_next::ValidationError> {
7381 Ok(())
7382 }
7383 }
7384
7385 unsafe impl ::fidl_next::Wire for Capability {
7386 type Narrowed<'de> = Capability;
7387
7388 #[inline]
7389 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7390 ::fidl_next::munge! {
7391 let Self {
7392 id,
7393 offset,
7394
7395 } = &mut *out_;
7396 }
7397
7398 ::fidl_next::Wire::zero_padding(id);
7399
7400 ::fidl_next::Wire::zero_padding(offset);
7401 }
7402 }
7403
7404 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability
7405 where
7406 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7407 {
7408 fn decode(
7409 slot_: ::fidl_next::Slot<'_, Self>,
7410 decoder_: &mut ___D,
7411 _: (),
7412 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7413 ::fidl_next::munge! {
7414 let Self {
7415 mut id,
7416 mut offset,
7417
7418 } = slot_;
7419 }
7420
7421 let _field = id.as_mut();
7422
7423 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7424
7425 let _field = offset.as_mut();
7426
7427 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7428
7429 Ok(())
7430 }
7431 }
7432
7433 impl ::fidl_next::IntoNatural for Capability {
7434 type Natural = crate::natural::Capability;
7435 }
7436
7437 #[derive(Clone, Debug)]
7439 #[repr(C)]
7440 pub struct ExtendedCapability {
7441 pub id: ::fidl_next::wire::Uint16,
7442
7443 pub offset: ::fidl_next::wire::Uint16,
7444 }
7445
7446 static_assertions::const_assert_eq!(std::mem::size_of::<ExtendedCapability>(), 4);
7447 static_assertions::const_assert_eq!(std::mem::align_of::<ExtendedCapability>(), 2);
7448
7449 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, id), 0);
7450
7451 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, offset), 2);
7452
7453 impl ::fidl_next::Constrained for ExtendedCapability {
7454 type Constraint = ();
7455
7456 fn validate(
7457 _: ::fidl_next::Slot<'_, Self>,
7458 _: Self::Constraint,
7459 ) -> Result<(), ::fidl_next::ValidationError> {
7460 Ok(())
7461 }
7462 }
7463
7464 unsafe impl ::fidl_next::Wire for ExtendedCapability {
7465 type Narrowed<'de> = ExtendedCapability;
7466
7467 #[inline]
7468 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7469 ::fidl_next::munge! {
7470 let Self {
7471 id,
7472 offset,
7473
7474 } = &mut *out_;
7475 }
7476
7477 ::fidl_next::Wire::zero_padding(id);
7478
7479 ::fidl_next::Wire::zero_padding(offset);
7480 }
7481 }
7482
7483 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapability
7484 where
7485 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7486 {
7487 fn decode(
7488 slot_: ::fidl_next::Slot<'_, Self>,
7489 decoder_: &mut ___D,
7490 _: (),
7491 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7492 ::fidl_next::munge! {
7493 let Self {
7494 mut id,
7495 mut offset,
7496
7497 } = slot_;
7498 }
7499
7500 let _field = id.as_mut();
7501
7502 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7503
7504 let _field = offset.as_mut();
7505
7506 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7507
7508 Ok(())
7509 }
7510 }
7511
7512 impl ::fidl_next::IntoNatural for ExtendedCapability {
7513 type Natural = crate::natural::ExtendedCapability;
7514 }
7515
7516 #[derive(Debug)]
7518 #[repr(C)]
7519 pub struct PciDevice<'de> {
7520 pub base_addresses: ::fidl_next::wire::Vector<'de, crate::wire::BaseAddress>,
7521
7522 pub capabilities: ::fidl_next::wire::Vector<'de, crate::wire::Capability>,
7523
7524 pub ext_capabilities: ::fidl_next::wire::Vector<'de, crate::wire::ExtendedCapability>,
7525
7526 pub config: ::fidl_next::wire::Vector<'de, u8>,
7527
7528 pub bus_id: u8,
7529
7530 pub device_id: u8,
7531
7532 pub function_id: u8,
7533 }
7534
7535 static_assertions::const_assert_eq!(std::mem::size_of::<PciDevice<'_>>(), 72);
7536 static_assertions::const_assert_eq!(std::mem::align_of::<PciDevice<'_>>(), 8);
7537
7538 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, base_addresses), 0);
7539
7540 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, capabilities), 16);
7541
7542 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, ext_capabilities), 32);
7543
7544 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, config), 48);
7545
7546 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, bus_id), 64);
7547
7548 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, device_id), 65);
7549
7550 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, function_id), 66);
7551
7552 impl ::fidl_next::Constrained for PciDevice<'_> {
7553 type Constraint = ();
7554
7555 fn validate(
7556 _: ::fidl_next::Slot<'_, Self>,
7557 _: Self::Constraint,
7558 ) -> Result<(), ::fidl_next::ValidationError> {
7559 Ok(())
7560 }
7561 }
7562
7563 unsafe impl ::fidl_next::Wire for PciDevice<'static> {
7564 type Narrowed<'de> = PciDevice<'de>;
7565
7566 #[inline]
7567 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7568 ::fidl_next::munge! {
7569 let Self {
7570 base_addresses,
7571 capabilities,
7572 ext_capabilities,
7573 config,
7574 bus_id,
7575 device_id,
7576 function_id,
7577
7578 } = &mut *out_;
7579 }
7580
7581 ::fidl_next::Wire::zero_padding(base_addresses);
7582
7583 ::fidl_next::Wire::zero_padding(capabilities);
7584
7585 ::fidl_next::Wire::zero_padding(ext_capabilities);
7586
7587 ::fidl_next::Wire::zero_padding(config);
7588
7589 ::fidl_next::Wire::zero_padding(bus_id);
7590
7591 ::fidl_next::Wire::zero_padding(device_id);
7592
7593 ::fidl_next::Wire::zero_padding(function_id);
7594
7595 unsafe {
7596 out_.as_mut_ptr().cast::<u8>().add(67).write_bytes(0, 5);
7597 }
7598 }
7599 }
7600
7601 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PciDevice<'de>
7602 where
7603 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7604 ___D: ::fidl_next::Decoder<'de>,
7605 {
7606 fn decode(
7607 slot_: ::fidl_next::Slot<'_, Self>,
7608 decoder_: &mut ___D,
7609 _: (),
7610 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7611 if slot_.as_bytes()[67..72] != [0u8; 5] {
7612 return Err(::fidl_next::DecodeError::InvalidPadding);
7613 }
7614
7615 ::fidl_next::munge! {
7616 let Self {
7617 mut base_addresses,
7618 mut capabilities,
7619 mut ext_capabilities,
7620 mut config,
7621 mut bus_id,
7622 mut device_id,
7623 mut function_id,
7624
7625 } = slot_;
7626 }
7627
7628 let _field = base_addresses.as_mut();
7629 ::fidl_next::Constrained::validate(_field, (6, ()))?;
7630 ::fidl_next::Decode::decode(base_addresses.as_mut(), decoder_, (6, ()))?;
7631
7632 let base_addresses = unsafe { base_addresses.deref_unchecked() };
7633
7634 if base_addresses.len() > 6 {
7635 return Err(::fidl_next::DecodeError::VectorTooLong {
7636 size: base_addresses.len() as u64,
7637 limit: 6,
7638 });
7639 }
7640
7641 let _field = capabilities.as_mut();
7642 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7643 ::fidl_next::Decode::decode(capabilities.as_mut(), decoder_, (32, ()))?;
7644
7645 let capabilities = unsafe { capabilities.deref_unchecked() };
7646
7647 if capabilities.len() > 32 {
7648 return Err(::fidl_next::DecodeError::VectorTooLong {
7649 size: capabilities.len() as u64,
7650 limit: 32,
7651 });
7652 }
7653
7654 let _field = ext_capabilities.as_mut();
7655 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7656 ::fidl_next::Decode::decode(ext_capabilities.as_mut(), decoder_, (32, ()))?;
7657
7658 let ext_capabilities = unsafe { ext_capabilities.deref_unchecked() };
7659
7660 if ext_capabilities.len() > 32 {
7661 return Err(::fidl_next::DecodeError::VectorTooLong {
7662 size: ext_capabilities.len() as u64,
7663 limit: 32,
7664 });
7665 }
7666
7667 let _field = config.as_mut();
7668 ::fidl_next::Constrained::validate(_field, (256, ()))?;
7669 ::fidl_next::Decode::decode(config.as_mut(), decoder_, (256, ()))?;
7670
7671 let config = unsafe { config.deref_unchecked() };
7672
7673 if config.len() > 256 {
7674 return Err(::fidl_next::DecodeError::VectorTooLong {
7675 size: config.len() as u64,
7676 limit: 256,
7677 });
7678 }
7679
7680 let _field = bus_id.as_mut();
7681
7682 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
7683
7684 let _field = device_id.as_mut();
7685
7686 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
7687
7688 let _field = function_id.as_mut();
7689
7690 ::fidl_next::Decode::decode(function_id.as_mut(), decoder_, ())?;
7691
7692 Ok(())
7693 }
7694 }
7695
7696 impl<'de> ::fidl_next::IntoNatural for PciDevice<'de> {
7697 type Natural = crate::natural::PciDevice;
7698 }
7699
7700 #[derive(Debug)]
7702 #[repr(C)]
7703 pub struct BusGetDevicesResponse<'de> {
7704 pub devices: ::fidl_next::wire::Vector<'de, crate::wire::PciDevice<'de>>,
7705 }
7706
7707 static_assertions::const_assert_eq!(std::mem::size_of::<BusGetDevicesResponse<'_>>(), 16);
7708 static_assertions::const_assert_eq!(std::mem::align_of::<BusGetDevicesResponse<'_>>(), 8);
7709
7710 static_assertions::const_assert_eq!(
7711 std::mem::offset_of!(BusGetDevicesResponse<'_>, devices),
7712 0
7713 );
7714
7715 impl ::fidl_next::Constrained for BusGetDevicesResponse<'_> {
7716 type Constraint = ();
7717
7718 fn validate(
7719 _: ::fidl_next::Slot<'_, Self>,
7720 _: Self::Constraint,
7721 ) -> Result<(), ::fidl_next::ValidationError> {
7722 Ok(())
7723 }
7724 }
7725
7726 unsafe impl ::fidl_next::Wire for BusGetDevicesResponse<'static> {
7727 type Narrowed<'de> = BusGetDevicesResponse<'de>;
7728
7729 #[inline]
7730 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7731 ::fidl_next::munge! {
7732 let Self {
7733 devices,
7734
7735 } = &mut *out_;
7736 }
7737
7738 ::fidl_next::Wire::zero_padding(devices);
7739 }
7740 }
7741
7742 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetDevicesResponse<'de>
7743 where
7744 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7745 ___D: ::fidl_next::Decoder<'de>,
7746 {
7747 fn decode(
7748 slot_: ::fidl_next::Slot<'_, Self>,
7749 decoder_: &mut ___D,
7750 _: (),
7751 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7752 ::fidl_next::munge! {
7753 let Self {
7754 mut devices,
7755
7756 } = slot_;
7757 }
7758
7759 let _field = devices.as_mut();
7760 ::fidl_next::Constrained::validate(_field, (64, ()))?;
7761 ::fidl_next::Decode::decode(devices.as_mut(), decoder_, (64, ()))?;
7762
7763 let devices = unsafe { devices.deref_unchecked() };
7764
7765 if devices.len() > 64 {
7766 return Err(::fidl_next::DecodeError::VectorTooLong {
7767 size: devices.len() as u64,
7768 limit: 64,
7769 });
7770 }
7771
7772 Ok(())
7773 }
7774 }
7775
7776 impl<'de> ::fidl_next::IntoNatural for BusGetDevicesResponse<'de> {
7777 type Natural = crate::natural::BusGetDevicesResponse;
7778 }
7779
7780 #[derive(Clone, Debug)]
7782 #[repr(C)]
7783 pub struct BusReadBarRequest {
7784 pub device: crate::wire::Address,
7785
7786 pub bar_id: u8,
7787
7788 pub offset: ::fidl_next::wire::Uint64,
7789
7790 pub size: ::fidl_next::wire::Uint64,
7791 }
7792
7793 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarRequest>(), 24);
7794 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarRequest>(), 8);
7795
7796 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, device), 0);
7797
7798 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, bar_id), 3);
7799
7800 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, offset), 8);
7801
7802 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, size), 16);
7803
7804 impl ::fidl_next::Constrained for BusReadBarRequest {
7805 type Constraint = ();
7806
7807 fn validate(
7808 _: ::fidl_next::Slot<'_, Self>,
7809 _: Self::Constraint,
7810 ) -> Result<(), ::fidl_next::ValidationError> {
7811 Ok(())
7812 }
7813 }
7814
7815 unsafe impl ::fidl_next::Wire for BusReadBarRequest {
7816 type Narrowed<'de> = BusReadBarRequest;
7817
7818 #[inline]
7819 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7820 ::fidl_next::munge! {
7821 let Self {
7822 device,
7823 bar_id,
7824 offset,
7825 size,
7826
7827 } = &mut *out_;
7828 }
7829
7830 ::fidl_next::Wire::zero_padding(device);
7831
7832 ::fidl_next::Wire::zero_padding(bar_id);
7833
7834 ::fidl_next::Wire::zero_padding(offset);
7835
7836 ::fidl_next::Wire::zero_padding(size);
7837
7838 unsafe {
7839 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
7840 }
7841 }
7842 }
7843
7844 unsafe impl<___D> ::fidl_next::Decode<___D> for BusReadBarRequest
7845 where
7846 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7847 {
7848 fn decode(
7849 slot_: ::fidl_next::Slot<'_, Self>,
7850 decoder_: &mut ___D,
7851 _: (),
7852 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7853 if slot_.as_bytes()[4..8] != [0u8; 4] {
7854 return Err(::fidl_next::DecodeError::InvalidPadding);
7855 }
7856
7857 ::fidl_next::munge! {
7858 let Self {
7859 mut device,
7860 mut bar_id,
7861 mut offset,
7862 mut size,
7863
7864 } = slot_;
7865 }
7866
7867 let _field = device.as_mut();
7868
7869 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
7870
7871 let _field = bar_id.as_mut();
7872
7873 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
7874
7875 let _field = offset.as_mut();
7876
7877 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7878
7879 let _field = size.as_mut();
7880
7881 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
7882
7883 Ok(())
7884 }
7885 }
7886
7887 impl ::fidl_next::IntoNatural for BusReadBarRequest {
7888 type Natural = crate::natural::BusReadBarRequest;
7889 }
7890
7891 #[derive(Debug)]
7893 #[repr(C)]
7894 pub struct BusReadBarResponse<'de> {
7895 pub buffer: ::fidl_next::wire::Vector<'de, u8>,
7896 }
7897
7898 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarResponse<'_>>(), 16);
7899 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarResponse<'_>>(), 8);
7900
7901 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarResponse<'_>, buffer), 0);
7902
7903 impl ::fidl_next::Constrained for BusReadBarResponse<'_> {
7904 type Constraint = ();
7905
7906 fn validate(
7907 _: ::fidl_next::Slot<'_, Self>,
7908 _: Self::Constraint,
7909 ) -> Result<(), ::fidl_next::ValidationError> {
7910 Ok(())
7911 }
7912 }
7913
7914 unsafe impl ::fidl_next::Wire for BusReadBarResponse<'static> {
7915 type Narrowed<'de> = BusReadBarResponse<'de>;
7916
7917 #[inline]
7918 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7919 ::fidl_next::munge! {
7920 let Self {
7921 buffer,
7922
7923 } = &mut *out_;
7924 }
7925
7926 ::fidl_next::Wire::zero_padding(buffer);
7927 }
7928 }
7929
7930 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusReadBarResponse<'de>
7931 where
7932 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7933 ___D: ::fidl_next::Decoder<'de>,
7934 {
7935 fn decode(
7936 slot_: ::fidl_next::Slot<'_, Self>,
7937 decoder_: &mut ___D,
7938 _: (),
7939 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7940 ::fidl_next::munge! {
7941 let Self {
7942 mut buffer,
7943
7944 } = slot_;
7945 }
7946
7947 let _field = buffer.as_mut();
7948 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
7949 ::fidl_next::Decode::decode(buffer.as_mut(), decoder_, (4294967295, ()))?;
7950
7951 Ok(())
7952 }
7953 }
7954
7955 impl<'de> ::fidl_next::IntoNatural for BusReadBarResponse<'de> {
7956 type Natural = crate::natural::BusReadBarResponse;
7957 }
7958
7959 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7961 #[repr(transparent)]
7962 pub struct CapabilityId {
7963 pub(crate) value: u8,
7964 }
7965
7966 impl ::fidl_next::Constrained for CapabilityId {
7967 type Constraint = ();
7968
7969 fn validate(
7970 _: ::fidl_next::Slot<'_, Self>,
7971 _: Self::Constraint,
7972 ) -> Result<(), ::fidl_next::ValidationError> {
7973 Ok(())
7974 }
7975 }
7976
7977 unsafe impl ::fidl_next::Wire for CapabilityId {
7978 type Narrowed<'de> = Self;
7979
7980 #[inline]
7981 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
7982 }
7984 }
7985
7986 impl CapabilityId {
7987 pub const NULL: CapabilityId = CapabilityId { value: 0 };
7988
7989 pub const PCI_PWR_MGMT: CapabilityId = CapabilityId { value: 1 };
7990
7991 pub const AGP: CapabilityId = CapabilityId { value: 2 };
7992
7993 pub const VITAL_PRODUCT_DATA: CapabilityId = CapabilityId { value: 3 };
7994
7995 pub const SLOT_IDENTIFICATION: CapabilityId = CapabilityId { value: 4 };
7996
7997 pub const MSI: CapabilityId = CapabilityId { value: 5 };
7998
7999 pub const COMPACT_PCI_HOTSWAP: CapabilityId = CapabilityId { value: 6 };
8000
8001 pub const PCIX: CapabilityId = CapabilityId { value: 7 };
8002
8003 pub const HYPERTRANSPORT: CapabilityId = CapabilityId { value: 8 };
8004
8005 pub const VENDOR: CapabilityId = CapabilityId { value: 9 };
8006
8007 pub const DEBUG_PORT: CapabilityId = CapabilityId { value: 10 };
8008
8009 pub const COMPACT_PCI_CRC: CapabilityId = CapabilityId { value: 11 };
8010
8011 pub const PCI_HOT_PLUG: CapabilityId = CapabilityId { value: 12 };
8012
8013 pub const PCI_BRIDGE_SUBSYSTEM_VID: CapabilityId = CapabilityId { value: 13 };
8014
8015 pub const AGP8_X: CapabilityId = CapabilityId { value: 14 };
8016
8017 pub const SECURE_DEVICE: CapabilityId = CapabilityId { value: 15 };
8018
8019 pub const PCI_EXPRESS: CapabilityId = CapabilityId { value: 16 };
8020
8021 pub const MSIX: CapabilityId = CapabilityId { value: 17 };
8022
8023 pub const SATA_DATA_NDX_CFG: CapabilityId = CapabilityId { value: 18 };
8024
8025 pub const ADVANCED_FEATURES: CapabilityId = CapabilityId { value: 19 };
8026
8027 pub const ENHANCED_ALLOCATION: CapabilityId = CapabilityId { value: 20 };
8028
8029 pub const FLATTENING_PORTAL_BRIDGE: CapabilityId = CapabilityId { value: 21 };
8030 }
8031
8032 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityId
8033 where
8034 ___D: ?Sized,
8035 {
8036 fn decode(
8037 slot: ::fidl_next::Slot<'_, Self>,
8038 _: &mut ___D,
8039 _: (),
8040 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8041 Ok(())
8042 }
8043 }
8044
8045 impl ::core::convert::From<crate::natural::CapabilityId> for CapabilityId {
8046 fn from(natural: crate::natural::CapabilityId) -> Self {
8047 match natural {
8048 crate::natural::CapabilityId::Null => CapabilityId::NULL,
8049
8050 crate::natural::CapabilityId::PciPwrMgmt => CapabilityId::PCI_PWR_MGMT,
8051
8052 crate::natural::CapabilityId::Agp => CapabilityId::AGP,
8053
8054 crate::natural::CapabilityId::VitalProductData => CapabilityId::VITAL_PRODUCT_DATA,
8055
8056 crate::natural::CapabilityId::SlotIdentification => {
8057 CapabilityId::SLOT_IDENTIFICATION
8058 }
8059
8060 crate::natural::CapabilityId::Msi => CapabilityId::MSI,
8061
8062 crate::natural::CapabilityId::CompactPciHotswap => {
8063 CapabilityId::COMPACT_PCI_HOTSWAP
8064 }
8065
8066 crate::natural::CapabilityId::Pcix => CapabilityId::PCIX,
8067
8068 crate::natural::CapabilityId::Hypertransport => CapabilityId::HYPERTRANSPORT,
8069
8070 crate::natural::CapabilityId::Vendor => CapabilityId::VENDOR,
8071
8072 crate::natural::CapabilityId::DebugPort => CapabilityId::DEBUG_PORT,
8073
8074 crate::natural::CapabilityId::CompactPciCrc => CapabilityId::COMPACT_PCI_CRC,
8075
8076 crate::natural::CapabilityId::PciHotPlug => CapabilityId::PCI_HOT_PLUG,
8077
8078 crate::natural::CapabilityId::PciBridgeSubsystemVid => {
8079 CapabilityId::PCI_BRIDGE_SUBSYSTEM_VID
8080 }
8081
8082 crate::natural::CapabilityId::Agp8X => CapabilityId::AGP8_X,
8083
8084 crate::natural::CapabilityId::SecureDevice => CapabilityId::SECURE_DEVICE,
8085
8086 crate::natural::CapabilityId::PciExpress => CapabilityId::PCI_EXPRESS,
8087
8088 crate::natural::CapabilityId::Msix => CapabilityId::MSIX,
8089
8090 crate::natural::CapabilityId::SataDataNdxCfg => CapabilityId::SATA_DATA_NDX_CFG,
8091
8092 crate::natural::CapabilityId::AdvancedFeatures => CapabilityId::ADVANCED_FEATURES,
8093
8094 crate::natural::CapabilityId::EnhancedAllocation => {
8095 CapabilityId::ENHANCED_ALLOCATION
8096 }
8097
8098 crate::natural::CapabilityId::FlatteningPortalBridge => {
8099 CapabilityId::FLATTENING_PORTAL_BRIDGE
8100 }
8101
8102 crate::natural::CapabilityId::UnknownOrdinal_(value) => {
8103 CapabilityId { value: u8::from(value) }
8104 }
8105 }
8106 }
8107 }
8108
8109 impl ::fidl_next::IntoNatural for CapabilityId {
8110 type Natural = crate::natural::CapabilityId;
8111 }
8112
8113 #[derive(Clone, Copy, Debug)]
8115 #[repr(transparent)]
8116 pub struct Command {
8117 pub(crate) value: ::fidl_next::wire::Uint16,
8118 }
8119
8120 impl ::fidl_next::Constrained for Command {
8121 type Constraint = ();
8122
8123 fn validate(
8124 _: ::fidl_next::Slot<'_, Self>,
8125 _: Self::Constraint,
8126 ) -> Result<(), ::fidl_next::ValidationError> {
8127 Ok(())
8128 }
8129 }
8130
8131 unsafe impl ::fidl_next::Wire for Command {
8132 type Narrowed<'de> = Self;
8133
8134 #[inline]
8135 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8136 }
8138 }
8139
8140 unsafe impl<___D> ::fidl_next::Decode<___D> for Command
8141 where
8142 ___D: ?Sized,
8143 {
8144 fn decode(
8145 slot: ::fidl_next::Slot<'_, Self>,
8146 _: &mut ___D,
8147 _: (),
8148 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8149 Ok(())
8150 }
8151 }
8152
8153 impl ::core::convert::From<crate::natural::Command> for Command {
8154 fn from(natural: crate::natural::Command) -> Self {
8155 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
8156 }
8157 }
8158
8159 impl ::fidl_next::IntoNatural for Command {
8160 type Natural = crate::natural::Command;
8161 }
8162
8163 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8165 #[repr(transparent)]
8166 pub struct Config {
8167 pub(crate) value: ::fidl_next::wire::Uint16,
8168 }
8169
8170 impl ::fidl_next::Constrained for Config {
8171 type Constraint = ();
8172
8173 fn validate(
8174 _: ::fidl_next::Slot<'_, Self>,
8175 _: Self::Constraint,
8176 ) -> Result<(), ::fidl_next::ValidationError> {
8177 Ok(())
8178 }
8179 }
8180
8181 unsafe impl ::fidl_next::Wire for Config {
8182 type Narrowed<'de> = Self;
8183
8184 #[inline]
8185 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8186 }
8188 }
8189
8190 impl Config {
8191 pub const VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(0) };
8192
8193 pub const DEVICE_ID: Config = Config { value: ::fidl_next::wire::Uint16(2) };
8194
8195 pub const COMMAND: Config = Config { value: ::fidl_next::wire::Uint16(4) };
8196
8197 pub const STATUS: Config = Config { value: ::fidl_next::wire::Uint16(6) };
8198
8199 pub const REVISION_ID: Config = Config { value: ::fidl_next::wire::Uint16(8) };
8200
8201 pub const CLASS_CODE_INTR: Config = Config { value: ::fidl_next::wire::Uint16(9) };
8202
8203 pub const CLASS_CODE_SUB: Config = Config { value: ::fidl_next::wire::Uint16(10) };
8204
8205 pub const CLASS_CODE_BASE: Config = Config { value: ::fidl_next::wire::Uint16(11) };
8206
8207 pub const CACHE_LINE_SIZE: Config = Config { value: ::fidl_next::wire::Uint16(12) };
8208
8209 pub const LATENCY_TIMER: Config = Config { value: ::fidl_next::wire::Uint16(13) };
8210
8211 pub const HEADER_TYPE: Config = Config { value: ::fidl_next::wire::Uint16(14) };
8212
8213 pub const BIST: Config = Config { value: ::fidl_next::wire::Uint16(15) };
8214
8215 pub const BASE_ADDRESSES: Config = Config { value: ::fidl_next::wire::Uint16(16) };
8216
8217 pub const CARDBUS_CIS_PTR: Config = Config { value: ::fidl_next::wire::Uint16(40) };
8218
8219 pub const SUBSYSTEM_VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(44) };
8220
8221 pub const SUBSYSTEM_ID: Config = Config { value: ::fidl_next::wire::Uint16(46) };
8222
8223 pub const EXP_ROM_ADDRESS: Config = Config { value: ::fidl_next::wire::Uint16(48) };
8224
8225 pub const CAPABILITIES_PTR: Config = Config { value: ::fidl_next::wire::Uint16(52) };
8226
8227 pub const INTERRUPT_LINE: Config = Config { value: ::fidl_next::wire::Uint16(60) };
8228
8229 pub const INTERRUPT_PIN: Config = Config { value: ::fidl_next::wire::Uint16(61) };
8230
8231 pub const MIN_GRANT: Config = Config { value: ::fidl_next::wire::Uint16(62) };
8232
8233 pub const MAX_LATENCY: Config = Config { value: ::fidl_next::wire::Uint16(63) };
8234 }
8235
8236 unsafe impl<___D> ::fidl_next::Decode<___D> for Config
8237 where
8238 ___D: ?Sized,
8239 {
8240 fn decode(
8241 slot: ::fidl_next::Slot<'_, Self>,
8242 _: &mut ___D,
8243 _: (),
8244 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8245 Ok(())
8246 }
8247 }
8248
8249 impl ::core::convert::From<crate::natural::Config> for Config {
8250 fn from(natural: crate::natural::Config) -> Self {
8251 match natural {
8252 crate::natural::Config::VendorId => Config::VENDOR_ID,
8253
8254 crate::natural::Config::DeviceId => Config::DEVICE_ID,
8255
8256 crate::natural::Config::Command => Config::COMMAND,
8257
8258 crate::natural::Config::Status => Config::STATUS,
8259
8260 crate::natural::Config::RevisionId => Config::REVISION_ID,
8261
8262 crate::natural::Config::ClassCodeIntr => Config::CLASS_CODE_INTR,
8263
8264 crate::natural::Config::ClassCodeSub => Config::CLASS_CODE_SUB,
8265
8266 crate::natural::Config::ClassCodeBase => Config::CLASS_CODE_BASE,
8267
8268 crate::natural::Config::CacheLineSize => Config::CACHE_LINE_SIZE,
8269
8270 crate::natural::Config::LatencyTimer => Config::LATENCY_TIMER,
8271
8272 crate::natural::Config::HeaderType => Config::HEADER_TYPE,
8273
8274 crate::natural::Config::Bist => Config::BIST,
8275
8276 crate::natural::Config::BaseAddresses => Config::BASE_ADDRESSES,
8277
8278 crate::natural::Config::CardbusCisPtr => Config::CARDBUS_CIS_PTR,
8279
8280 crate::natural::Config::SubsystemVendorId => Config::SUBSYSTEM_VENDOR_ID,
8281
8282 crate::natural::Config::SubsystemId => Config::SUBSYSTEM_ID,
8283
8284 crate::natural::Config::ExpRomAddress => Config::EXP_ROM_ADDRESS,
8285
8286 crate::natural::Config::CapabilitiesPtr => Config::CAPABILITIES_PTR,
8287
8288 crate::natural::Config::InterruptLine => Config::INTERRUPT_LINE,
8289
8290 crate::natural::Config::InterruptPin => Config::INTERRUPT_PIN,
8291
8292 crate::natural::Config::MinGrant => Config::MIN_GRANT,
8293
8294 crate::natural::Config::MaxLatency => Config::MAX_LATENCY,
8295
8296 crate::natural::Config::UnknownOrdinal_(value) => {
8297 Config { value: ::fidl_next::wire::Uint16::from(value) }
8298 }
8299 }
8300 }
8301 }
8302
8303 impl ::fidl_next::IntoNatural for Config {
8304 type Natural = crate::natural::Config;
8305 }
8306
8307 pub type ConfigOffset = u8;
8309
8310 pub type Padding = ::fidl_next::wire::Unit;
8312
8313 #[derive(Clone, Debug)]
8315 #[repr(C)]
8316 pub struct DeviceInfo {
8317 pub vendor_id: ::fidl_next::wire::Uint16,
8318
8319 pub device_id: ::fidl_next::wire::Uint16,
8320
8321 pub base_class: u8,
8322
8323 pub sub_class: u8,
8324
8325 pub program_interface: u8,
8326
8327 pub revision_id: u8,
8328
8329 pub bus_id: u8,
8330
8331 pub dev_id: u8,
8332
8333 pub func_id: u8,
8334
8335 pub padding: crate::wire::Padding,
8336 }
8337
8338 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceInfo>(), 12);
8339 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceInfo>(), 2);
8340
8341 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, vendor_id), 0);
8342
8343 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, device_id), 2);
8344
8345 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, base_class), 4);
8346
8347 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, sub_class), 5);
8348
8349 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, program_interface), 6);
8350
8351 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, revision_id), 7);
8352
8353 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, bus_id), 8);
8354
8355 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, dev_id), 9);
8356
8357 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, func_id), 10);
8358
8359 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, padding), 11);
8360
8361 impl ::fidl_next::Constrained for DeviceInfo {
8362 type Constraint = ();
8363
8364 fn validate(
8365 _: ::fidl_next::Slot<'_, Self>,
8366 _: Self::Constraint,
8367 ) -> Result<(), ::fidl_next::ValidationError> {
8368 Ok(())
8369 }
8370 }
8371
8372 unsafe impl ::fidl_next::Wire for DeviceInfo {
8373 type Narrowed<'de> = DeviceInfo;
8374
8375 #[inline]
8376 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8377 ::fidl_next::munge! {
8378 let Self {
8379 vendor_id,
8380 device_id,
8381 base_class,
8382 sub_class,
8383 program_interface,
8384 revision_id,
8385 bus_id,
8386 dev_id,
8387 func_id,
8388 padding,
8389
8390 } = &mut *out_;
8391 }
8392
8393 ::fidl_next::Wire::zero_padding(vendor_id);
8394
8395 ::fidl_next::Wire::zero_padding(device_id);
8396
8397 ::fidl_next::Wire::zero_padding(base_class);
8398
8399 ::fidl_next::Wire::zero_padding(sub_class);
8400
8401 ::fidl_next::Wire::zero_padding(program_interface);
8402
8403 ::fidl_next::Wire::zero_padding(revision_id);
8404
8405 ::fidl_next::Wire::zero_padding(bus_id);
8406
8407 ::fidl_next::Wire::zero_padding(dev_id);
8408
8409 ::fidl_next::Wire::zero_padding(func_id);
8410
8411 ::fidl_next::Wire::zero_padding(padding);
8412 }
8413 }
8414
8415 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceInfo
8416 where
8417 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8418 {
8419 fn decode(
8420 slot_: ::fidl_next::Slot<'_, Self>,
8421 decoder_: &mut ___D,
8422 _: (),
8423 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8424 ::fidl_next::munge! {
8425 let Self {
8426 mut vendor_id,
8427 mut device_id,
8428 mut base_class,
8429 mut sub_class,
8430 mut program_interface,
8431 mut revision_id,
8432 mut bus_id,
8433 mut dev_id,
8434 mut func_id,
8435 mut padding,
8436
8437 } = slot_;
8438 }
8439
8440 let _field = vendor_id.as_mut();
8441
8442 ::fidl_next::Decode::decode(vendor_id.as_mut(), decoder_, ())?;
8443
8444 let _field = device_id.as_mut();
8445
8446 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
8447
8448 let _field = base_class.as_mut();
8449
8450 ::fidl_next::Decode::decode(base_class.as_mut(), decoder_, ())?;
8451
8452 let _field = sub_class.as_mut();
8453
8454 ::fidl_next::Decode::decode(sub_class.as_mut(), decoder_, ())?;
8455
8456 let _field = program_interface.as_mut();
8457
8458 ::fidl_next::Decode::decode(program_interface.as_mut(), decoder_, ())?;
8459
8460 let _field = revision_id.as_mut();
8461
8462 ::fidl_next::Decode::decode(revision_id.as_mut(), decoder_, ())?;
8463
8464 let _field = bus_id.as_mut();
8465
8466 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
8467
8468 let _field = dev_id.as_mut();
8469
8470 ::fidl_next::Decode::decode(dev_id.as_mut(), decoder_, ())?;
8471
8472 let _field = func_id.as_mut();
8473
8474 ::fidl_next::Decode::decode(func_id.as_mut(), decoder_, ())?;
8475
8476 let _field = padding.as_mut();
8477
8478 ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
8479
8480 Ok(())
8481 }
8482 }
8483
8484 impl ::fidl_next::IntoNatural for DeviceInfo {
8485 type Natural = crate::natural::DeviceInfo;
8486 }
8487
8488 #[derive(Clone, Debug)]
8490 #[repr(C)]
8491 pub struct DeviceGetDeviceInfoResponse {
8492 pub info: crate::wire::DeviceInfo,
8493 }
8494
8495 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetDeviceInfoResponse>(), 12);
8496 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetDeviceInfoResponse>(), 2);
8497
8498 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetDeviceInfoResponse, info), 0);
8499
8500 impl ::fidl_next::Constrained for DeviceGetDeviceInfoResponse {
8501 type Constraint = ();
8502
8503 fn validate(
8504 _: ::fidl_next::Slot<'_, Self>,
8505 _: Self::Constraint,
8506 ) -> Result<(), ::fidl_next::ValidationError> {
8507 Ok(())
8508 }
8509 }
8510
8511 unsafe impl ::fidl_next::Wire for DeviceGetDeviceInfoResponse {
8512 type Narrowed<'de> = DeviceGetDeviceInfoResponse;
8513
8514 #[inline]
8515 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8516 ::fidl_next::munge! {
8517 let Self {
8518 info,
8519
8520 } = &mut *out_;
8521 }
8522
8523 ::fidl_next::Wire::zero_padding(info);
8524 }
8525 }
8526
8527 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetDeviceInfoResponse
8528 where
8529 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8530 {
8531 fn decode(
8532 slot_: ::fidl_next::Slot<'_, Self>,
8533 decoder_: &mut ___D,
8534 _: (),
8535 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8536 ::fidl_next::munge! {
8537 let Self {
8538 mut info,
8539
8540 } = slot_;
8541 }
8542
8543 let _field = info.as_mut();
8544
8545 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
8546
8547 Ok(())
8548 }
8549 }
8550
8551 impl ::fidl_next::IntoNatural for DeviceGetDeviceInfoResponse {
8552 type Natural = crate::natural::DeviceGetDeviceInfoResponse;
8553 }
8554
8555 #[derive(Clone, Debug)]
8557 #[repr(C)]
8558 pub struct DeviceGetBarRequest {
8559 pub bar_id: ::fidl_next::wire::Uint32,
8560 }
8561
8562 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBarRequest>(), 4);
8563 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBarRequest>(), 4);
8564
8565 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBarRequest, bar_id), 0);
8566
8567 impl ::fidl_next::Constrained for DeviceGetBarRequest {
8568 type Constraint = ();
8569
8570 fn validate(
8571 _: ::fidl_next::Slot<'_, Self>,
8572 _: Self::Constraint,
8573 ) -> Result<(), ::fidl_next::ValidationError> {
8574 Ok(())
8575 }
8576 }
8577
8578 unsafe impl ::fidl_next::Wire for DeviceGetBarRequest {
8579 type Narrowed<'de> = DeviceGetBarRequest;
8580
8581 #[inline]
8582 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8583 ::fidl_next::munge! {
8584 let Self {
8585 bar_id,
8586
8587 } = &mut *out_;
8588 }
8589
8590 ::fidl_next::Wire::zero_padding(bar_id);
8591 }
8592 }
8593
8594 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBarRequest
8595 where
8596 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8597 {
8598 fn decode(
8599 slot_: ::fidl_next::Slot<'_, Self>,
8600 decoder_: &mut ___D,
8601 _: (),
8602 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8603 ::fidl_next::munge! {
8604 let Self {
8605 mut bar_id,
8606
8607 } = slot_;
8608 }
8609
8610 let _field = bar_id.as_mut();
8611
8612 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
8613
8614 Ok(())
8615 }
8616 }
8617
8618 impl ::fidl_next::IntoNatural for DeviceGetBarRequest {
8619 type Natural = crate::natural::DeviceGetBarRequest;
8620 }
8621
8622 #[derive(Clone, Debug)]
8624 #[repr(C)]
8625 pub struct DeviceSetBusMasteringRequest {
8626 pub enabled: bool,
8627 }
8628
8629 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetBusMasteringRequest>(), 1);
8630 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetBusMasteringRequest>(), 1);
8631
8632 static_assertions::const_assert_eq!(
8633 std::mem::offset_of!(DeviceSetBusMasteringRequest, enabled),
8634 0
8635 );
8636
8637 impl ::fidl_next::Constrained for DeviceSetBusMasteringRequest {
8638 type Constraint = ();
8639
8640 fn validate(
8641 _: ::fidl_next::Slot<'_, Self>,
8642 _: Self::Constraint,
8643 ) -> Result<(), ::fidl_next::ValidationError> {
8644 Ok(())
8645 }
8646 }
8647
8648 unsafe impl ::fidl_next::Wire for DeviceSetBusMasteringRequest {
8649 type Narrowed<'de> = DeviceSetBusMasteringRequest;
8650
8651 #[inline]
8652 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8653 ::fidl_next::munge! {
8654 let Self {
8655 enabled,
8656
8657 } = &mut *out_;
8658 }
8659
8660 ::fidl_next::Wire::zero_padding(enabled);
8661 }
8662 }
8663
8664 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetBusMasteringRequest
8665 where
8666 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8667 {
8668 fn decode(
8669 slot_: ::fidl_next::Slot<'_, Self>,
8670 decoder_: &mut ___D,
8671 _: (),
8672 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8673 ::fidl_next::munge! {
8674 let Self {
8675 mut enabled,
8676
8677 } = slot_;
8678 }
8679
8680 let _field = enabled.as_mut();
8681
8682 ::fidl_next::Decode::decode(enabled.as_mut(), decoder_, ())?;
8683
8684 Ok(())
8685 }
8686 }
8687
8688 impl ::fidl_next::IntoNatural for DeviceSetBusMasteringRequest {
8689 type Natural = crate::natural::DeviceSetBusMasteringRequest;
8690 }
8691
8692 pub type DeviceSetBusMasteringResponse = ::fidl_next::wire::Unit;
8694
8695 pub type DeviceResetDeviceResponse = ::fidl_next::wire::Unit;
8697
8698 pub type DeviceAckInterruptResponse = ::fidl_next::wire::Unit;
8700
8701 #[derive(Clone, Debug)]
8703 #[repr(C)]
8704 pub struct DeviceMapInterruptRequest {
8705 pub which_irq: ::fidl_next::wire::Uint32,
8706 }
8707
8708 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceMapInterruptRequest>(), 4);
8709 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceMapInterruptRequest>(), 4);
8710
8711 static_assertions::const_assert_eq!(
8712 std::mem::offset_of!(DeviceMapInterruptRequest, which_irq),
8713 0
8714 );
8715
8716 impl ::fidl_next::Constrained for DeviceMapInterruptRequest {
8717 type Constraint = ();
8718
8719 fn validate(
8720 _: ::fidl_next::Slot<'_, Self>,
8721 _: Self::Constraint,
8722 ) -> Result<(), ::fidl_next::ValidationError> {
8723 Ok(())
8724 }
8725 }
8726
8727 unsafe impl ::fidl_next::Wire for DeviceMapInterruptRequest {
8728 type Narrowed<'de> = DeviceMapInterruptRequest;
8729
8730 #[inline]
8731 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8732 ::fidl_next::munge! {
8733 let Self {
8734 which_irq,
8735
8736 } = &mut *out_;
8737 }
8738
8739 ::fidl_next::Wire::zero_padding(which_irq);
8740 }
8741 }
8742
8743 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceMapInterruptRequest
8744 where
8745 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8746 {
8747 fn decode(
8748 slot_: ::fidl_next::Slot<'_, Self>,
8749 decoder_: &mut ___D,
8750 _: (),
8751 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8752 ::fidl_next::munge! {
8753 let Self {
8754 mut which_irq,
8755
8756 } = slot_;
8757 }
8758
8759 let _field = which_irq.as_mut();
8760
8761 ::fidl_next::Decode::decode(which_irq.as_mut(), decoder_, ())?;
8762
8763 Ok(())
8764 }
8765 }
8766
8767 impl ::fidl_next::IntoNatural for DeviceMapInterruptRequest {
8768 type Natural = crate::natural::DeviceMapInterruptRequest;
8769 }
8770
8771 #[derive(Clone, Debug)]
8773 #[repr(C)]
8774 pub struct InterruptModes {
8775 pub has_legacy: bool,
8776
8777 pub msi_count: u8,
8778
8779 pub msix_count: ::fidl_next::wire::Uint16,
8780 }
8781
8782 static_assertions::const_assert_eq!(std::mem::size_of::<InterruptModes>(), 4);
8783 static_assertions::const_assert_eq!(std::mem::align_of::<InterruptModes>(), 2);
8784
8785 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, has_legacy), 0);
8786
8787 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msi_count), 1);
8788
8789 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msix_count), 2);
8790
8791 impl ::fidl_next::Constrained for InterruptModes {
8792 type Constraint = ();
8793
8794 fn validate(
8795 _: ::fidl_next::Slot<'_, Self>,
8796 _: Self::Constraint,
8797 ) -> Result<(), ::fidl_next::ValidationError> {
8798 Ok(())
8799 }
8800 }
8801
8802 unsafe impl ::fidl_next::Wire for InterruptModes {
8803 type Narrowed<'de> = InterruptModes;
8804
8805 #[inline]
8806 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8807 ::fidl_next::munge! {
8808 let Self {
8809 has_legacy,
8810 msi_count,
8811 msix_count,
8812
8813 } = &mut *out_;
8814 }
8815
8816 ::fidl_next::Wire::zero_padding(has_legacy);
8817
8818 ::fidl_next::Wire::zero_padding(msi_count);
8819
8820 ::fidl_next::Wire::zero_padding(msix_count);
8821 }
8822 }
8823
8824 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptModes
8825 where
8826 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8827 {
8828 fn decode(
8829 slot_: ::fidl_next::Slot<'_, Self>,
8830 decoder_: &mut ___D,
8831 _: (),
8832 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8833 ::fidl_next::munge! {
8834 let Self {
8835 mut has_legacy,
8836 mut msi_count,
8837 mut msix_count,
8838
8839 } = slot_;
8840 }
8841
8842 let _field = has_legacy.as_mut();
8843
8844 ::fidl_next::Decode::decode(has_legacy.as_mut(), decoder_, ())?;
8845
8846 let _field = msi_count.as_mut();
8847
8848 ::fidl_next::Decode::decode(msi_count.as_mut(), decoder_, ())?;
8849
8850 let _field = msix_count.as_mut();
8851
8852 ::fidl_next::Decode::decode(msix_count.as_mut(), decoder_, ())?;
8853
8854 Ok(())
8855 }
8856 }
8857
8858 impl ::fidl_next::IntoNatural for InterruptModes {
8859 type Natural = crate::natural::InterruptModes;
8860 }
8861
8862 #[derive(Clone, Debug)]
8864 #[repr(C)]
8865 pub struct DeviceGetInterruptModesResponse {
8866 pub modes: crate::wire::InterruptModes,
8867 }
8868
8869 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetInterruptModesResponse>(), 4);
8870 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetInterruptModesResponse>(), 2);
8871
8872 static_assertions::const_assert_eq!(
8873 std::mem::offset_of!(DeviceGetInterruptModesResponse, modes),
8874 0
8875 );
8876
8877 impl ::fidl_next::Constrained for DeviceGetInterruptModesResponse {
8878 type Constraint = ();
8879
8880 fn validate(
8881 _: ::fidl_next::Slot<'_, Self>,
8882 _: Self::Constraint,
8883 ) -> Result<(), ::fidl_next::ValidationError> {
8884 Ok(())
8885 }
8886 }
8887
8888 unsafe impl ::fidl_next::Wire for DeviceGetInterruptModesResponse {
8889 type Narrowed<'de> = DeviceGetInterruptModesResponse;
8890
8891 #[inline]
8892 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8893 ::fidl_next::munge! {
8894 let Self {
8895 modes,
8896
8897 } = &mut *out_;
8898 }
8899
8900 ::fidl_next::Wire::zero_padding(modes);
8901 }
8902 }
8903
8904 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetInterruptModesResponse
8905 where
8906 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8907 {
8908 fn decode(
8909 slot_: ::fidl_next::Slot<'_, Self>,
8910 decoder_: &mut ___D,
8911 _: (),
8912 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8913 ::fidl_next::munge! {
8914 let Self {
8915 mut modes,
8916
8917 } = slot_;
8918 }
8919
8920 let _field = modes.as_mut();
8921
8922 ::fidl_next::Decode::decode(modes.as_mut(), decoder_, ())?;
8923
8924 Ok(())
8925 }
8926 }
8927
8928 impl ::fidl_next::IntoNatural for DeviceGetInterruptModesResponse {
8929 type Natural = crate::natural::DeviceGetInterruptModesResponse;
8930 }
8931
8932 pub type DeviceSetInterruptModeResponse = ::fidl_next::wire::Unit;
8934
8935 pub type ExtendedConfigOffset = ::fidl_next::wire::Uint16;
8937
8938 #[derive(Clone, Debug)]
8940 #[repr(C)]
8941 pub struct DeviceReadConfig8Request {
8942 pub offset: ::fidl_next::wire::Uint16,
8943 }
8944
8945 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Request>(), 2);
8946 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Request>(), 2);
8947
8948 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Request, offset), 0);
8949
8950 impl ::fidl_next::Constrained for DeviceReadConfig8Request {
8951 type Constraint = ();
8952
8953 fn validate(
8954 _: ::fidl_next::Slot<'_, Self>,
8955 _: Self::Constraint,
8956 ) -> Result<(), ::fidl_next::ValidationError> {
8957 Ok(())
8958 }
8959 }
8960
8961 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Request {
8962 type Narrowed<'de> = DeviceReadConfig8Request;
8963
8964 #[inline]
8965 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8966 ::fidl_next::munge! {
8967 let Self {
8968 offset,
8969
8970 } = &mut *out_;
8971 }
8972
8973 ::fidl_next::Wire::zero_padding(offset);
8974 }
8975 }
8976
8977 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Request
8978 where
8979 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8980 {
8981 fn decode(
8982 slot_: ::fidl_next::Slot<'_, Self>,
8983 decoder_: &mut ___D,
8984 _: (),
8985 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8986 ::fidl_next::munge! {
8987 let Self {
8988 mut offset,
8989
8990 } = slot_;
8991 }
8992
8993 let _field = offset.as_mut();
8994
8995 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8996
8997 Ok(())
8998 }
8999 }
9000
9001 impl ::fidl_next::IntoNatural for DeviceReadConfig8Request {
9002 type Natural = crate::natural::DeviceReadConfig8Request;
9003 }
9004
9005 #[derive(Clone, Debug)]
9007 #[repr(C)]
9008 pub struct DeviceReadConfig8Response {
9009 pub value: u8,
9010 }
9011
9012 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Response>(), 1);
9013 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Response>(), 1);
9014
9015 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Response, value), 0);
9016
9017 impl ::fidl_next::Constrained for DeviceReadConfig8Response {
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 DeviceReadConfig8Response {
9029 type Narrowed<'de> = DeviceReadConfig8Response;
9030
9031 #[inline]
9032 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9033 ::fidl_next::munge! {
9034 let Self {
9035 value,
9036
9037 } = &mut *out_;
9038 }
9039
9040 ::fidl_next::Wire::zero_padding(value);
9041 }
9042 }
9043
9044 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Response
9045 where
9046 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9047 {
9048 fn decode(
9049 slot_: ::fidl_next::Slot<'_, Self>,
9050 decoder_: &mut ___D,
9051 _: (),
9052 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9053 ::fidl_next::munge! {
9054 let Self {
9055 mut value,
9056
9057 } = slot_;
9058 }
9059
9060 let _field = value.as_mut();
9061
9062 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9063
9064 Ok(())
9065 }
9066 }
9067
9068 impl ::fidl_next::IntoNatural for DeviceReadConfig8Response {
9069 type Natural = crate::natural::DeviceReadConfig8Response;
9070 }
9071
9072 #[derive(Clone, Debug)]
9074 #[repr(C)]
9075 pub struct DeviceReadConfig16Request {
9076 pub offset: ::fidl_next::wire::Uint16,
9077 }
9078
9079 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Request>(), 2);
9080 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Request>(), 2);
9081
9082 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Request, offset), 0);
9083
9084 impl ::fidl_next::Constrained for DeviceReadConfig16Request {
9085 type Constraint = ();
9086
9087 fn validate(
9088 _: ::fidl_next::Slot<'_, Self>,
9089 _: Self::Constraint,
9090 ) -> Result<(), ::fidl_next::ValidationError> {
9091 Ok(())
9092 }
9093 }
9094
9095 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Request {
9096 type Narrowed<'de> = DeviceReadConfig16Request;
9097
9098 #[inline]
9099 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9100 ::fidl_next::munge! {
9101 let Self {
9102 offset,
9103
9104 } = &mut *out_;
9105 }
9106
9107 ::fidl_next::Wire::zero_padding(offset);
9108 }
9109 }
9110
9111 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Request
9112 where
9113 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9114 {
9115 fn decode(
9116 slot_: ::fidl_next::Slot<'_, Self>,
9117 decoder_: &mut ___D,
9118 _: (),
9119 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9120 ::fidl_next::munge! {
9121 let Self {
9122 mut offset,
9123
9124 } = slot_;
9125 }
9126
9127 let _field = offset.as_mut();
9128
9129 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9130
9131 Ok(())
9132 }
9133 }
9134
9135 impl ::fidl_next::IntoNatural for DeviceReadConfig16Request {
9136 type Natural = crate::natural::DeviceReadConfig16Request;
9137 }
9138
9139 #[derive(Clone, Debug)]
9141 #[repr(C)]
9142 pub struct DeviceReadConfig16Response {
9143 pub value: ::fidl_next::wire::Uint16,
9144 }
9145
9146 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Response>(), 2);
9147 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Response>(), 2);
9148
9149 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Response, value), 0);
9150
9151 impl ::fidl_next::Constrained for DeviceReadConfig16Response {
9152 type Constraint = ();
9153
9154 fn validate(
9155 _: ::fidl_next::Slot<'_, Self>,
9156 _: Self::Constraint,
9157 ) -> Result<(), ::fidl_next::ValidationError> {
9158 Ok(())
9159 }
9160 }
9161
9162 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Response {
9163 type Narrowed<'de> = DeviceReadConfig16Response;
9164
9165 #[inline]
9166 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9167 ::fidl_next::munge! {
9168 let Self {
9169 value,
9170
9171 } = &mut *out_;
9172 }
9173
9174 ::fidl_next::Wire::zero_padding(value);
9175 }
9176 }
9177
9178 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Response
9179 where
9180 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9181 {
9182 fn decode(
9183 slot_: ::fidl_next::Slot<'_, Self>,
9184 decoder_: &mut ___D,
9185 _: (),
9186 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9187 ::fidl_next::munge! {
9188 let Self {
9189 mut value,
9190
9191 } = slot_;
9192 }
9193
9194 let _field = value.as_mut();
9195
9196 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9197
9198 Ok(())
9199 }
9200 }
9201
9202 impl ::fidl_next::IntoNatural for DeviceReadConfig16Response {
9203 type Natural = crate::natural::DeviceReadConfig16Response;
9204 }
9205
9206 #[derive(Clone, Debug)]
9208 #[repr(C)]
9209 pub struct DeviceReadConfig32Request {
9210 pub offset: ::fidl_next::wire::Uint16,
9211 }
9212
9213 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Request>(), 2);
9214 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Request>(), 2);
9215
9216 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Request, offset), 0);
9217
9218 impl ::fidl_next::Constrained for DeviceReadConfig32Request {
9219 type Constraint = ();
9220
9221 fn validate(
9222 _: ::fidl_next::Slot<'_, Self>,
9223 _: Self::Constraint,
9224 ) -> Result<(), ::fidl_next::ValidationError> {
9225 Ok(())
9226 }
9227 }
9228
9229 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Request {
9230 type Narrowed<'de> = DeviceReadConfig32Request;
9231
9232 #[inline]
9233 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9234 ::fidl_next::munge! {
9235 let Self {
9236 offset,
9237
9238 } = &mut *out_;
9239 }
9240
9241 ::fidl_next::Wire::zero_padding(offset);
9242 }
9243 }
9244
9245 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Request
9246 where
9247 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9248 {
9249 fn decode(
9250 slot_: ::fidl_next::Slot<'_, Self>,
9251 decoder_: &mut ___D,
9252 _: (),
9253 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9254 ::fidl_next::munge! {
9255 let Self {
9256 mut offset,
9257
9258 } = slot_;
9259 }
9260
9261 let _field = offset.as_mut();
9262
9263 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9264
9265 Ok(())
9266 }
9267 }
9268
9269 impl ::fidl_next::IntoNatural for DeviceReadConfig32Request {
9270 type Natural = crate::natural::DeviceReadConfig32Request;
9271 }
9272
9273 #[derive(Clone, Debug)]
9275 #[repr(C)]
9276 pub struct DeviceReadConfig32Response {
9277 pub value: ::fidl_next::wire::Uint32,
9278 }
9279
9280 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Response>(), 4);
9281 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Response>(), 4);
9282
9283 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Response, value), 0);
9284
9285 impl ::fidl_next::Constrained for DeviceReadConfig32Response {
9286 type Constraint = ();
9287
9288 fn validate(
9289 _: ::fidl_next::Slot<'_, Self>,
9290 _: Self::Constraint,
9291 ) -> Result<(), ::fidl_next::ValidationError> {
9292 Ok(())
9293 }
9294 }
9295
9296 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Response {
9297 type Narrowed<'de> = DeviceReadConfig32Response;
9298
9299 #[inline]
9300 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9301 ::fidl_next::munge! {
9302 let Self {
9303 value,
9304
9305 } = &mut *out_;
9306 }
9307
9308 ::fidl_next::Wire::zero_padding(value);
9309 }
9310 }
9311
9312 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Response
9313 where
9314 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9315 {
9316 fn decode(
9317 slot_: ::fidl_next::Slot<'_, Self>,
9318 decoder_: &mut ___D,
9319 _: (),
9320 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9321 ::fidl_next::munge! {
9322 let Self {
9323 mut value,
9324
9325 } = slot_;
9326 }
9327
9328 let _field = value.as_mut();
9329
9330 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9331
9332 Ok(())
9333 }
9334 }
9335
9336 impl ::fidl_next::IntoNatural for DeviceReadConfig32Response {
9337 type Natural = crate::natural::DeviceReadConfig32Response;
9338 }
9339
9340 #[derive(Clone, Debug)]
9342 #[repr(C)]
9343 pub struct DeviceWriteConfig8Request {
9344 pub offset: ::fidl_next::wire::Uint16,
9345
9346 pub value: u8,
9347 }
9348
9349 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig8Request>(), 4);
9350 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig8Request>(), 2);
9351
9352 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, offset), 0);
9353
9354 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, value), 2);
9355
9356 impl ::fidl_next::Constrained for DeviceWriteConfig8Request {
9357 type Constraint = ();
9358
9359 fn validate(
9360 _: ::fidl_next::Slot<'_, Self>,
9361 _: Self::Constraint,
9362 ) -> Result<(), ::fidl_next::ValidationError> {
9363 Ok(())
9364 }
9365 }
9366
9367 unsafe impl ::fidl_next::Wire for DeviceWriteConfig8Request {
9368 type Narrowed<'de> = DeviceWriteConfig8Request;
9369
9370 #[inline]
9371 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9372 ::fidl_next::munge! {
9373 let Self {
9374 offset,
9375 value,
9376
9377 } = &mut *out_;
9378 }
9379
9380 ::fidl_next::Wire::zero_padding(offset);
9381
9382 ::fidl_next::Wire::zero_padding(value);
9383
9384 unsafe {
9385 out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 1);
9386 }
9387 }
9388 }
9389
9390 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig8Request
9391 where
9392 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9393 {
9394 fn decode(
9395 slot_: ::fidl_next::Slot<'_, Self>,
9396 decoder_: &mut ___D,
9397 _: (),
9398 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9399 if slot_.as_bytes()[3..4] != [0u8; 1] {
9400 return Err(::fidl_next::DecodeError::InvalidPadding);
9401 }
9402
9403 ::fidl_next::munge! {
9404 let Self {
9405 mut offset,
9406 mut value,
9407
9408 } = slot_;
9409 }
9410
9411 let _field = offset.as_mut();
9412
9413 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9414
9415 let _field = value.as_mut();
9416
9417 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9418
9419 Ok(())
9420 }
9421 }
9422
9423 impl ::fidl_next::IntoNatural for DeviceWriteConfig8Request {
9424 type Natural = crate::natural::DeviceWriteConfig8Request;
9425 }
9426
9427 pub type DeviceWriteConfig8Response = ::fidl_next::wire::Unit;
9429
9430 #[derive(Clone, Debug)]
9432 #[repr(C)]
9433 pub struct DeviceWriteConfig16Request {
9434 pub offset: ::fidl_next::wire::Uint16,
9435
9436 pub value: ::fidl_next::wire::Uint16,
9437 }
9438
9439 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig16Request>(), 4);
9440 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig16Request>(), 2);
9441
9442 static_assertions::const_assert_eq!(
9443 std::mem::offset_of!(DeviceWriteConfig16Request, offset),
9444 0
9445 );
9446
9447 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig16Request, value), 2);
9448
9449 impl ::fidl_next::Constrained for DeviceWriteConfig16Request {
9450 type Constraint = ();
9451
9452 fn validate(
9453 _: ::fidl_next::Slot<'_, Self>,
9454 _: Self::Constraint,
9455 ) -> Result<(), ::fidl_next::ValidationError> {
9456 Ok(())
9457 }
9458 }
9459
9460 unsafe impl ::fidl_next::Wire for DeviceWriteConfig16Request {
9461 type Narrowed<'de> = DeviceWriteConfig16Request;
9462
9463 #[inline]
9464 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9465 ::fidl_next::munge! {
9466 let Self {
9467 offset,
9468 value,
9469
9470 } = &mut *out_;
9471 }
9472
9473 ::fidl_next::Wire::zero_padding(offset);
9474
9475 ::fidl_next::Wire::zero_padding(value);
9476 }
9477 }
9478
9479 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig16Request
9480 where
9481 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9482 {
9483 fn decode(
9484 slot_: ::fidl_next::Slot<'_, Self>,
9485 decoder_: &mut ___D,
9486 _: (),
9487 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9488 ::fidl_next::munge! {
9489 let Self {
9490 mut offset,
9491 mut value,
9492
9493 } = slot_;
9494 }
9495
9496 let _field = offset.as_mut();
9497
9498 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9499
9500 let _field = value.as_mut();
9501
9502 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9503
9504 Ok(())
9505 }
9506 }
9507
9508 impl ::fidl_next::IntoNatural for DeviceWriteConfig16Request {
9509 type Natural = crate::natural::DeviceWriteConfig16Request;
9510 }
9511
9512 pub type DeviceWriteConfig16Response = ::fidl_next::wire::Unit;
9514
9515 #[derive(Clone, Debug)]
9517 #[repr(C)]
9518 pub struct DeviceWriteConfig32Request {
9519 pub offset: ::fidl_next::wire::Uint16,
9520
9521 pub value: ::fidl_next::wire::Uint32,
9522 }
9523
9524 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig32Request>(), 8);
9525 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig32Request>(), 4);
9526
9527 static_assertions::const_assert_eq!(
9528 std::mem::offset_of!(DeviceWriteConfig32Request, offset),
9529 0
9530 );
9531
9532 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig32Request, value), 4);
9533
9534 impl ::fidl_next::Constrained for DeviceWriteConfig32Request {
9535 type Constraint = ();
9536
9537 fn validate(
9538 _: ::fidl_next::Slot<'_, Self>,
9539 _: Self::Constraint,
9540 ) -> Result<(), ::fidl_next::ValidationError> {
9541 Ok(())
9542 }
9543 }
9544
9545 unsafe impl ::fidl_next::Wire for DeviceWriteConfig32Request {
9546 type Narrowed<'de> = DeviceWriteConfig32Request;
9547
9548 #[inline]
9549 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9550 ::fidl_next::munge! {
9551 let Self {
9552 offset,
9553 value,
9554
9555 } = &mut *out_;
9556 }
9557
9558 ::fidl_next::Wire::zero_padding(offset);
9559
9560 ::fidl_next::Wire::zero_padding(value);
9561
9562 unsafe {
9563 out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 2);
9564 }
9565 }
9566 }
9567
9568 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig32Request
9569 where
9570 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9571 {
9572 fn decode(
9573 slot_: ::fidl_next::Slot<'_, Self>,
9574 decoder_: &mut ___D,
9575 _: (),
9576 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9577 if slot_.as_bytes()[2..4] != [0u8; 2] {
9578 return Err(::fidl_next::DecodeError::InvalidPadding);
9579 }
9580
9581 ::fidl_next::munge! {
9582 let Self {
9583 mut offset,
9584 mut value,
9585
9586 } = slot_;
9587 }
9588
9589 let _field = offset.as_mut();
9590
9591 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9592
9593 let _field = value.as_mut();
9594
9595 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9596
9597 Ok(())
9598 }
9599 }
9600
9601 impl ::fidl_next::IntoNatural for DeviceWriteConfig32Request {
9602 type Natural = crate::natural::DeviceWriteConfig32Request;
9603 }
9604
9605 pub type DeviceWriteConfig32Response = ::fidl_next::wire::Unit;
9607
9608 #[derive(Clone, Debug)]
9610 #[repr(C)]
9611 pub struct DeviceGetCapabilitiesRequest {
9612 pub id: crate::wire::CapabilityId,
9613 }
9614
9615 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetCapabilitiesRequest>(), 1);
9616 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetCapabilitiesRequest>(), 1);
9617
9618 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetCapabilitiesRequest, id), 0);
9619
9620 impl ::fidl_next::Constrained for DeviceGetCapabilitiesRequest {
9621 type Constraint = ();
9622
9623 fn validate(
9624 _: ::fidl_next::Slot<'_, Self>,
9625 _: Self::Constraint,
9626 ) -> Result<(), ::fidl_next::ValidationError> {
9627 Ok(())
9628 }
9629 }
9630
9631 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesRequest {
9632 type Narrowed<'de> = DeviceGetCapabilitiesRequest;
9633
9634 #[inline]
9635 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9636 ::fidl_next::munge! {
9637 let Self {
9638 id,
9639
9640 } = &mut *out_;
9641 }
9642
9643 ::fidl_next::Wire::zero_padding(id);
9644 }
9645 }
9646
9647 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesRequest
9648 where
9649 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9650 {
9651 fn decode(
9652 slot_: ::fidl_next::Slot<'_, Self>,
9653 decoder_: &mut ___D,
9654 _: (),
9655 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9656 ::fidl_next::munge! {
9657 let Self {
9658 mut id,
9659
9660 } = slot_;
9661 }
9662
9663 let _field = id.as_mut();
9664
9665 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9666
9667 Ok(())
9668 }
9669 }
9670
9671 impl ::fidl_next::IntoNatural for DeviceGetCapabilitiesRequest {
9672 type Natural = crate::natural::DeviceGetCapabilitiesRequest;
9673 }
9674
9675 #[derive(Debug)]
9677 #[repr(C)]
9678 pub struct DeviceGetCapabilitiesResponse<'de> {
9679 pub offsets: ::fidl_next::wire::Vector<'de, u8>,
9680 }
9681
9682 static_assertions::const_assert_eq!(
9683 std::mem::size_of::<DeviceGetCapabilitiesResponse<'_>>(),
9684 16
9685 );
9686 static_assertions::const_assert_eq!(
9687 std::mem::align_of::<DeviceGetCapabilitiesResponse<'_>>(),
9688 8
9689 );
9690
9691 static_assertions::const_assert_eq!(
9692 std::mem::offset_of!(DeviceGetCapabilitiesResponse<'_>, offsets),
9693 0
9694 );
9695
9696 impl ::fidl_next::Constrained for DeviceGetCapabilitiesResponse<'_> {
9697 type Constraint = ();
9698
9699 fn validate(
9700 _: ::fidl_next::Slot<'_, Self>,
9701 _: Self::Constraint,
9702 ) -> Result<(), ::fidl_next::ValidationError> {
9703 Ok(())
9704 }
9705 }
9706
9707 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesResponse<'static> {
9708 type Narrowed<'de> = DeviceGetCapabilitiesResponse<'de>;
9709
9710 #[inline]
9711 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9712 ::fidl_next::munge! {
9713 let Self {
9714 offsets,
9715
9716 } = &mut *out_;
9717 }
9718
9719 ::fidl_next::Wire::zero_padding(offsets);
9720 }
9721 }
9722
9723 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesResponse<'de>
9724 where
9725 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9726 ___D: ::fidl_next::Decoder<'de>,
9727 {
9728 fn decode(
9729 slot_: ::fidl_next::Slot<'_, Self>,
9730 decoder_: &mut ___D,
9731 _: (),
9732 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9733 ::fidl_next::munge! {
9734 let Self {
9735 mut offsets,
9736
9737 } = slot_;
9738 }
9739
9740 let _field = offsets.as_mut();
9741 ::fidl_next::Constrained::validate(_field, (32, ()))?;
9742 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
9743
9744 let offsets = unsafe { offsets.deref_unchecked() };
9745
9746 if offsets.len() > 32 {
9747 return Err(::fidl_next::DecodeError::VectorTooLong {
9748 size: offsets.len() as u64,
9749 limit: 32,
9750 });
9751 }
9752
9753 Ok(())
9754 }
9755 }
9756
9757 impl<'de> ::fidl_next::IntoNatural for DeviceGetCapabilitiesResponse<'de> {
9758 type Natural = crate::natural::DeviceGetCapabilitiesResponse;
9759 }
9760
9761 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9763 #[repr(transparent)]
9764 pub struct ExtendedCapabilityId {
9765 pub(crate) value: ::fidl_next::wire::Uint16,
9766 }
9767
9768 impl ::fidl_next::Constrained for ExtendedCapabilityId {
9769 type Constraint = ();
9770
9771 fn validate(
9772 _: ::fidl_next::Slot<'_, Self>,
9773 _: Self::Constraint,
9774 ) -> Result<(), ::fidl_next::ValidationError> {
9775 Ok(())
9776 }
9777 }
9778
9779 unsafe impl ::fidl_next::Wire for ExtendedCapabilityId {
9780 type Narrowed<'de> = Self;
9781
9782 #[inline]
9783 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9784 }
9786 }
9787
9788 impl ExtendedCapabilityId {
9789 pub const NULL: ExtendedCapabilityId =
9790 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(0) };
9791
9792 pub const ADVANCED_ERROR_REPORTING: ExtendedCapabilityId =
9793 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(1) };
9794
9795 pub const VIRTUAL_CHANNEL_NO_MFVC: ExtendedCapabilityId =
9796 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(2) };
9797
9798 pub const DEVICE_SERIAL_NUMBER: ExtendedCapabilityId =
9799 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(3) };
9800
9801 pub const POWER_BUDGETING: ExtendedCapabilityId =
9802 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(4) };
9803
9804 pub const ROOT_COMPLEX_LINK_DECLARATION: ExtendedCapabilityId =
9805 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(5) };
9806
9807 pub const ROOT_COMPLEX_INTERNAL_LINK_CONTROL: ExtendedCapabilityId =
9808 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(6) };
9809
9810 pub const ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION: ExtendedCapabilityId =
9811 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(7) };
9812
9813 pub const MULTI_FUNCTION_VIRTUAL_CHANNEL: ExtendedCapabilityId =
9814 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(8) };
9815
9816 pub const VIRTUAL_CHANNEL: ExtendedCapabilityId =
9817 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(9) };
9818
9819 pub const RCRB: ExtendedCapabilityId =
9820 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(10) };
9821
9822 pub const VENDOR: ExtendedCapabilityId =
9823 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(11) };
9824
9825 pub const CAC: ExtendedCapabilityId =
9826 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(12) };
9827
9828 pub const ACS: ExtendedCapabilityId =
9829 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(13) };
9830
9831 pub const ARI: ExtendedCapabilityId =
9832 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(14) };
9833
9834 pub const ATS: ExtendedCapabilityId =
9835 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(15) };
9836
9837 pub const SR_IOV: ExtendedCapabilityId =
9838 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(16) };
9839
9840 pub const MR_IOV: ExtendedCapabilityId =
9841 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(17) };
9842
9843 pub const MULTICAST: ExtendedCapabilityId =
9844 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(18) };
9845
9846 pub const PRI: ExtendedCapabilityId =
9847 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(19) };
9848
9849 pub const ENHANCED_ALLOCATION: ExtendedCapabilityId =
9850 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(20) };
9851
9852 pub const RESIZABLE_BAR: ExtendedCapabilityId =
9853 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(21) };
9854
9855 pub const DYNAMIC_POWER_ALLOCATION: ExtendedCapabilityId =
9856 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(22) };
9857
9858 pub const TPH: ExtendedCapabilityId =
9859 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(23) };
9860
9861 pub const LATENCY_TOLERANCE_REPORTING: ExtendedCapabilityId =
9862 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(24) };
9863
9864 pub const SECONDARY_PCI_EXPRESS: ExtendedCapabilityId =
9865 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(25) };
9866
9867 pub const PMUX: ExtendedCapabilityId =
9868 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(26) };
9869
9870 pub const PASID: ExtendedCapabilityId =
9871 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(27) };
9872
9873 pub const LNR: ExtendedCapabilityId =
9874 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(28) };
9875
9876 pub const DPC: ExtendedCapabilityId =
9877 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(29) };
9878
9879 pub const L1_PM_SUBSTATES: ExtendedCapabilityId =
9880 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(30) };
9881
9882 pub const PRECISION_TIME_MEASUREMENT: ExtendedCapabilityId =
9883 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(31) };
9884
9885 pub const MPCIE: ExtendedCapabilityId =
9886 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(32) };
9887
9888 pub const FRS_QUEUEING: ExtendedCapabilityId =
9889 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(33) };
9890
9891 pub const READINESS_TIME_REPORTING: ExtendedCapabilityId =
9892 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(34) };
9893
9894 pub const DESIGNATED_VENDOR: ExtendedCapabilityId =
9895 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(35) };
9896
9897 pub const VF_RESIZABLE_BAR: ExtendedCapabilityId =
9898 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(36) };
9899
9900 pub const DATA_LINK_FEATURE: ExtendedCapabilityId =
9901 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(37) };
9902
9903 pub const PHYSICAL_LAYER_16: ExtendedCapabilityId =
9904 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(38) };
9905
9906 pub const LANE_MARGINING_AT_RECEIVER: ExtendedCapabilityId =
9907 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(39) };
9908
9909 pub const HIERARCHY_ID: ExtendedCapabilityId =
9910 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(40) };
9911
9912 pub const NATIVE_PCIE_ENCLOSURE: ExtendedCapabilityId =
9913 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(41) };
9914
9915 pub const PHYSICAL_LAYER_32: ExtendedCapabilityId =
9916 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(42) };
9917
9918 pub const ALTERNATE_PROTOCOL: ExtendedCapabilityId =
9919 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(43) };
9920
9921 pub const SYSTEM_FIRMWARE_INTERMEDIARY: ExtendedCapabilityId =
9922 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(44) };
9923 }
9924
9925 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapabilityId
9926 where
9927 ___D: ?Sized,
9928 {
9929 fn decode(
9930 slot: ::fidl_next::Slot<'_, Self>,
9931 _: &mut ___D,
9932 _: (),
9933 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9934 Ok(())
9935 }
9936 }
9937
9938 impl ::core::convert::From<crate::natural::ExtendedCapabilityId> for ExtendedCapabilityId {
9939 fn from(natural: crate::natural::ExtendedCapabilityId) -> Self {
9940 match natural {
9941
9942 crate::natural::ExtendedCapabilityId::Null => ExtendedCapabilityId::NULL,
9943
9944 crate::natural::ExtendedCapabilityId::AdvancedErrorReporting => ExtendedCapabilityId::ADVANCED_ERROR_REPORTING,
9945
9946 crate::natural::ExtendedCapabilityId::VirtualChannelNoMfvc => ExtendedCapabilityId::VIRTUAL_CHANNEL_NO_MFVC,
9947
9948 crate::natural::ExtendedCapabilityId::DeviceSerialNumber => ExtendedCapabilityId::DEVICE_SERIAL_NUMBER,
9949
9950 crate::natural::ExtendedCapabilityId::PowerBudgeting => ExtendedCapabilityId::POWER_BUDGETING,
9951
9952 crate::natural::ExtendedCapabilityId::RootComplexLinkDeclaration => ExtendedCapabilityId::ROOT_COMPLEX_LINK_DECLARATION,
9953
9954 crate::natural::ExtendedCapabilityId::RootComplexInternalLinkControl => ExtendedCapabilityId::ROOT_COMPLEX_INTERNAL_LINK_CONTROL,
9955
9956 crate::natural::ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => ExtendedCapabilityId::ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION,
9957
9958 crate::natural::ExtendedCapabilityId::MultiFunctionVirtualChannel => ExtendedCapabilityId::MULTI_FUNCTION_VIRTUAL_CHANNEL,
9959
9960 crate::natural::ExtendedCapabilityId::VirtualChannel => ExtendedCapabilityId::VIRTUAL_CHANNEL,
9961
9962 crate::natural::ExtendedCapabilityId::Rcrb => ExtendedCapabilityId::RCRB,
9963
9964 crate::natural::ExtendedCapabilityId::Vendor => ExtendedCapabilityId::VENDOR,
9965
9966 crate::natural::ExtendedCapabilityId::Cac => ExtendedCapabilityId::CAC,
9967
9968 crate::natural::ExtendedCapabilityId::Acs => ExtendedCapabilityId::ACS,
9969
9970 crate::natural::ExtendedCapabilityId::Ari => ExtendedCapabilityId::ARI,
9971
9972 crate::natural::ExtendedCapabilityId::Ats => ExtendedCapabilityId::ATS,
9973
9974 crate::natural::ExtendedCapabilityId::SrIov => ExtendedCapabilityId::SR_IOV,
9975
9976 crate::natural::ExtendedCapabilityId::MrIov => ExtendedCapabilityId::MR_IOV,
9977
9978 crate::natural::ExtendedCapabilityId::Multicast => ExtendedCapabilityId::MULTICAST,
9979
9980 crate::natural::ExtendedCapabilityId::Pri => ExtendedCapabilityId::PRI,
9981
9982 crate::natural::ExtendedCapabilityId::EnhancedAllocation => ExtendedCapabilityId::ENHANCED_ALLOCATION,
9983
9984 crate::natural::ExtendedCapabilityId::ResizableBar => ExtendedCapabilityId::RESIZABLE_BAR,
9985
9986 crate::natural::ExtendedCapabilityId::DynamicPowerAllocation => ExtendedCapabilityId::DYNAMIC_POWER_ALLOCATION,
9987
9988 crate::natural::ExtendedCapabilityId::Tph => ExtendedCapabilityId::TPH,
9989
9990 crate::natural::ExtendedCapabilityId::LatencyToleranceReporting => ExtendedCapabilityId::LATENCY_TOLERANCE_REPORTING,
9991
9992 crate::natural::ExtendedCapabilityId::SecondaryPciExpress => ExtendedCapabilityId::SECONDARY_PCI_EXPRESS,
9993
9994 crate::natural::ExtendedCapabilityId::Pmux => ExtendedCapabilityId::PMUX,
9995
9996 crate::natural::ExtendedCapabilityId::Pasid => ExtendedCapabilityId::PASID,
9997
9998 crate::natural::ExtendedCapabilityId::Lnr => ExtendedCapabilityId::LNR,
9999
10000 crate::natural::ExtendedCapabilityId::Dpc => ExtendedCapabilityId::DPC,
10001
10002 crate::natural::ExtendedCapabilityId::L1PmSubstates => ExtendedCapabilityId::L1_PM_SUBSTATES,
10003
10004 crate::natural::ExtendedCapabilityId::PrecisionTimeMeasurement => ExtendedCapabilityId::PRECISION_TIME_MEASUREMENT,
10005
10006 crate::natural::ExtendedCapabilityId::Mpcie => ExtendedCapabilityId::MPCIE,
10007
10008 crate::natural::ExtendedCapabilityId::FrsQueueing => ExtendedCapabilityId::FRS_QUEUEING,
10009
10010 crate::natural::ExtendedCapabilityId::ReadinessTimeReporting => ExtendedCapabilityId::READINESS_TIME_REPORTING,
10011
10012 crate::natural::ExtendedCapabilityId::DesignatedVendor => ExtendedCapabilityId::DESIGNATED_VENDOR,
10013
10014 crate::natural::ExtendedCapabilityId::VfResizableBar => ExtendedCapabilityId::VF_RESIZABLE_BAR,
10015
10016 crate::natural::ExtendedCapabilityId::DataLinkFeature => ExtendedCapabilityId::DATA_LINK_FEATURE,
10017
10018 crate::natural::ExtendedCapabilityId::PhysicalLayer16 => ExtendedCapabilityId::PHYSICAL_LAYER_16,
10019
10020 crate::natural::ExtendedCapabilityId::LaneMarginingAtReceiver => ExtendedCapabilityId::LANE_MARGINING_AT_RECEIVER,
10021
10022 crate::natural::ExtendedCapabilityId::HierarchyId => ExtendedCapabilityId::HIERARCHY_ID,
10023
10024 crate::natural::ExtendedCapabilityId::NativePcieEnclosure => ExtendedCapabilityId::NATIVE_PCIE_ENCLOSURE,
10025
10026 crate::natural::ExtendedCapabilityId::PhysicalLayer32 => ExtendedCapabilityId::PHYSICAL_LAYER_32,
10027
10028 crate::natural::ExtendedCapabilityId::AlternateProtocol => ExtendedCapabilityId::ALTERNATE_PROTOCOL,
10029
10030 crate::natural::ExtendedCapabilityId::SystemFirmwareIntermediary => ExtendedCapabilityId::SYSTEM_FIRMWARE_INTERMEDIARY,
10031
10032
10033 crate::natural::ExtendedCapabilityId::UnknownOrdinal_(value) => ExtendedCapabilityId {
10034 value: ::fidl_next::wire::Uint16::from(value),
10035 }
10036
10037 }
10038 }
10039 }
10040
10041 impl ::fidl_next::IntoNatural for ExtendedCapabilityId {
10042 type Natural = crate::natural::ExtendedCapabilityId;
10043 }
10044
10045 #[derive(Clone, Debug)]
10047 #[repr(C)]
10048 pub struct DeviceGetExtendedCapabilitiesRequest {
10049 pub id: crate::wire::ExtendedCapabilityId,
10050 }
10051
10052 static_assertions::const_assert_eq!(
10053 std::mem::size_of::<DeviceGetExtendedCapabilitiesRequest>(),
10054 2
10055 );
10056 static_assertions::const_assert_eq!(
10057 std::mem::align_of::<DeviceGetExtendedCapabilitiesRequest>(),
10058 2
10059 );
10060
10061 static_assertions::const_assert_eq!(
10062 std::mem::offset_of!(DeviceGetExtendedCapabilitiesRequest, id),
10063 0
10064 );
10065
10066 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesRequest {
10067 type Constraint = ();
10068
10069 fn validate(
10070 _: ::fidl_next::Slot<'_, Self>,
10071 _: Self::Constraint,
10072 ) -> Result<(), ::fidl_next::ValidationError> {
10073 Ok(())
10074 }
10075 }
10076
10077 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesRequest {
10078 type Narrowed<'de> = DeviceGetExtendedCapabilitiesRequest;
10079
10080 #[inline]
10081 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10082 ::fidl_next::munge! {
10083 let Self {
10084 id,
10085
10086 } = &mut *out_;
10087 }
10088
10089 ::fidl_next::Wire::zero_padding(id);
10090 }
10091 }
10092
10093 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesRequest
10094 where
10095 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10096 {
10097 fn decode(
10098 slot_: ::fidl_next::Slot<'_, Self>,
10099 decoder_: &mut ___D,
10100 _: (),
10101 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10102 ::fidl_next::munge! {
10103 let Self {
10104 mut id,
10105
10106 } = slot_;
10107 }
10108
10109 let _field = id.as_mut();
10110
10111 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10112
10113 Ok(())
10114 }
10115 }
10116
10117 impl ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesRequest {
10118 type Natural = crate::natural::DeviceGetExtendedCapabilitiesRequest;
10119 }
10120
10121 #[derive(Debug)]
10123 #[repr(C)]
10124 pub struct DeviceGetExtendedCapabilitiesResponse<'de> {
10125 pub offsets: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
10126 }
10127
10128 static_assertions::const_assert_eq!(
10129 std::mem::size_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10130 16
10131 );
10132 static_assertions::const_assert_eq!(
10133 std::mem::align_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10134 8
10135 );
10136
10137 static_assertions::const_assert_eq!(
10138 std::mem::offset_of!(DeviceGetExtendedCapabilitiesResponse<'_>, offsets),
10139 0
10140 );
10141
10142 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesResponse<'_> {
10143 type Constraint = ();
10144
10145 fn validate(
10146 _: ::fidl_next::Slot<'_, Self>,
10147 _: Self::Constraint,
10148 ) -> Result<(), ::fidl_next::ValidationError> {
10149 Ok(())
10150 }
10151 }
10152
10153 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesResponse<'static> {
10154 type Narrowed<'de> = DeviceGetExtendedCapabilitiesResponse<'de>;
10155
10156 #[inline]
10157 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10158 ::fidl_next::munge! {
10159 let Self {
10160 offsets,
10161
10162 } = &mut *out_;
10163 }
10164
10165 ::fidl_next::Wire::zero_padding(offsets);
10166 }
10167 }
10168
10169 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesResponse<'de>
10170 where
10171 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10172 ___D: ::fidl_next::Decoder<'de>,
10173 {
10174 fn decode(
10175 slot_: ::fidl_next::Slot<'_, Self>,
10176 decoder_: &mut ___D,
10177 _: (),
10178 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10179 ::fidl_next::munge! {
10180 let Self {
10181 mut offsets,
10182
10183 } = slot_;
10184 }
10185
10186 let _field = offsets.as_mut();
10187 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10188 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
10189
10190 let offsets = unsafe { offsets.deref_unchecked() };
10191
10192 if offsets.len() > 32 {
10193 return Err(::fidl_next::DecodeError::VectorTooLong {
10194 size: offsets.len() as u64,
10195 limit: 32,
10196 });
10197 }
10198
10199 Ok(())
10200 }
10201 }
10202
10203 impl<'de> ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesResponse<'de> {
10204 type Natural = crate::natural::DeviceGetExtendedCapabilitiesResponse;
10205 }
10206
10207 #[derive(Clone, Debug)]
10209 #[repr(C)]
10210 pub struct DeviceGetBtiRequest {
10211 pub index: ::fidl_next::wire::Uint32,
10212 }
10213
10214 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBtiRequest>(), 4);
10215 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBtiRequest>(), 4);
10216
10217 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBtiRequest, index), 0);
10218
10219 impl ::fidl_next::Constrained for DeviceGetBtiRequest {
10220 type Constraint = ();
10221
10222 fn validate(
10223 _: ::fidl_next::Slot<'_, Self>,
10224 _: Self::Constraint,
10225 ) -> Result<(), ::fidl_next::ValidationError> {
10226 Ok(())
10227 }
10228 }
10229
10230 unsafe impl ::fidl_next::Wire for DeviceGetBtiRequest {
10231 type Narrowed<'de> = DeviceGetBtiRequest;
10232
10233 #[inline]
10234 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10235 ::fidl_next::munge! {
10236 let Self {
10237 index,
10238
10239 } = &mut *out_;
10240 }
10241
10242 ::fidl_next::Wire::zero_padding(index);
10243 }
10244 }
10245
10246 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBtiRequest
10247 where
10248 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10249 {
10250 fn decode(
10251 slot_: ::fidl_next::Slot<'_, Self>,
10252 decoder_: &mut ___D,
10253 _: (),
10254 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10255 ::fidl_next::munge! {
10256 let Self {
10257 mut index,
10258
10259 } = slot_;
10260 }
10261
10262 let _field = index.as_mut();
10263
10264 ::fidl_next::Decode::decode(index.as_mut(), decoder_, ())?;
10265
10266 Ok(())
10267 }
10268 }
10269
10270 impl ::fidl_next::IntoNatural for DeviceGetBtiRequest {
10271 type Natural = crate::natural::DeviceGetBtiRequest;
10272 }
10273
10274 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10276 #[repr(transparent)]
10277 pub struct InterruptMode {
10278 pub(crate) value: u8,
10279 }
10280
10281 impl ::fidl_next::Constrained for InterruptMode {
10282 type Constraint = ();
10283
10284 fn validate(
10285 _: ::fidl_next::Slot<'_, Self>,
10286 _: Self::Constraint,
10287 ) -> Result<(), ::fidl_next::ValidationError> {
10288 Ok(())
10289 }
10290 }
10291
10292 unsafe impl ::fidl_next::Wire for InterruptMode {
10293 type Narrowed<'de> = Self;
10294
10295 #[inline]
10296 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10297 }
10299 }
10300
10301 impl InterruptMode {
10302 pub const DISABLED: InterruptMode = InterruptMode { value: 0 };
10303
10304 pub const LEGACY: InterruptMode = InterruptMode { value: 1 };
10305
10306 pub const LEGACY_NOACK: InterruptMode = InterruptMode { value: 2 };
10307
10308 pub const MSI: InterruptMode = InterruptMode { value: 3 };
10309
10310 pub const MSI_X: InterruptMode = InterruptMode { value: 4 };
10311 }
10312
10313 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptMode
10314 where
10315 ___D: ?Sized,
10316 {
10317 fn decode(
10318 slot: ::fidl_next::Slot<'_, Self>,
10319 _: &mut ___D,
10320 _: (),
10321 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10322 Ok(())
10323 }
10324 }
10325
10326 impl ::core::convert::From<crate::natural::InterruptMode> for InterruptMode {
10327 fn from(natural: crate::natural::InterruptMode) -> Self {
10328 match natural {
10329 crate::natural::InterruptMode::Disabled => InterruptMode::DISABLED,
10330
10331 crate::natural::InterruptMode::Legacy => InterruptMode::LEGACY,
10332
10333 crate::natural::InterruptMode::LegacyNoack => InterruptMode::LEGACY_NOACK,
10334
10335 crate::natural::InterruptMode::Msi => InterruptMode::MSI,
10336
10337 crate::natural::InterruptMode::MsiX => InterruptMode::MSI_X,
10338
10339 crate::natural::InterruptMode::UnknownOrdinal_(value) => {
10340 InterruptMode { value: u8::from(value) }
10341 }
10342 }
10343 }
10344 }
10345
10346 impl ::fidl_next::IntoNatural for InterruptMode {
10347 type Natural = crate::natural::InterruptMode;
10348 }
10349
10350 #[derive(Clone, Debug)]
10352 #[repr(C)]
10353 pub struct DeviceSetInterruptModeRequest {
10354 pub mode: crate::wire::InterruptMode,
10355
10356 pub requested_irq_count: ::fidl_next::wire::Uint32,
10357 }
10358
10359 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetInterruptModeRequest>(), 8);
10360 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetInterruptModeRequest>(), 4);
10361
10362 static_assertions::const_assert_eq!(
10363 std::mem::offset_of!(DeviceSetInterruptModeRequest, mode),
10364 0
10365 );
10366
10367 static_assertions::const_assert_eq!(
10368 std::mem::offset_of!(DeviceSetInterruptModeRequest, requested_irq_count),
10369 4
10370 );
10371
10372 impl ::fidl_next::Constrained for DeviceSetInterruptModeRequest {
10373 type Constraint = ();
10374
10375 fn validate(
10376 _: ::fidl_next::Slot<'_, Self>,
10377 _: Self::Constraint,
10378 ) -> Result<(), ::fidl_next::ValidationError> {
10379 Ok(())
10380 }
10381 }
10382
10383 unsafe impl ::fidl_next::Wire for DeviceSetInterruptModeRequest {
10384 type Narrowed<'de> = DeviceSetInterruptModeRequest;
10385
10386 #[inline]
10387 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10388 ::fidl_next::munge! {
10389 let Self {
10390 mode,
10391 requested_irq_count,
10392
10393 } = &mut *out_;
10394 }
10395
10396 ::fidl_next::Wire::zero_padding(mode);
10397
10398 ::fidl_next::Wire::zero_padding(requested_irq_count);
10399
10400 unsafe {
10401 out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
10402 }
10403 }
10404 }
10405
10406 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetInterruptModeRequest
10407 where
10408 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10409 {
10410 fn decode(
10411 slot_: ::fidl_next::Slot<'_, Self>,
10412 decoder_: &mut ___D,
10413 _: (),
10414 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10415 if slot_.as_bytes()[1..4] != [0u8; 3] {
10416 return Err(::fidl_next::DecodeError::InvalidPadding);
10417 }
10418
10419 ::fidl_next::munge! {
10420 let Self {
10421 mut mode,
10422 mut requested_irq_count,
10423
10424 } = slot_;
10425 }
10426
10427 let _field = mode.as_mut();
10428
10429 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
10430
10431 let _field = requested_irq_count.as_mut();
10432
10433 ::fidl_next::Decode::decode(requested_irq_count.as_mut(), decoder_, ())?;
10434
10435 Ok(())
10436 }
10437 }
10438
10439 impl ::fidl_next::IntoNatural for DeviceSetInterruptModeRequest {
10440 type Natural = crate::natural::DeviceSetInterruptModeRequest;
10441 }
10442
10443 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10445 #[repr(transparent)]
10446 pub struct HeaderType {
10447 pub(crate) value: u8,
10448 }
10449
10450 impl ::fidl_next::Constrained for HeaderType {
10451 type Constraint = ();
10452
10453 fn validate(
10454 _: ::fidl_next::Slot<'_, Self>,
10455 _: Self::Constraint,
10456 ) -> Result<(), ::fidl_next::ValidationError> {
10457 Ok(())
10458 }
10459 }
10460
10461 unsafe impl ::fidl_next::Wire for HeaderType {
10462 type Narrowed<'de> = Self;
10463
10464 #[inline]
10465 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10466 }
10468 }
10469
10470 impl HeaderType {
10471 pub const STANDARD: HeaderType = HeaderType { value: 0 };
10472
10473 pub const BRIDGE: HeaderType = HeaderType { value: 1 };
10474
10475 pub const CARD_BUS: HeaderType = HeaderType { value: 2 };
10476
10477 pub const MASK: HeaderType = HeaderType { value: 127 };
10478
10479 pub const MULTI_FN: HeaderType = HeaderType { value: 128 };
10480 }
10481
10482 unsafe impl<___D> ::fidl_next::Decode<___D> for HeaderType
10483 where
10484 ___D: ?Sized,
10485 {
10486 fn decode(
10487 slot: ::fidl_next::Slot<'_, Self>,
10488 _: &mut ___D,
10489 _: (),
10490 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10491 Ok(())
10492 }
10493 }
10494
10495 impl ::core::convert::From<crate::natural::HeaderType> for HeaderType {
10496 fn from(natural: crate::natural::HeaderType) -> Self {
10497 match natural {
10498 crate::natural::HeaderType::Standard => HeaderType::STANDARD,
10499
10500 crate::natural::HeaderType::Bridge => HeaderType::BRIDGE,
10501
10502 crate::natural::HeaderType::CardBus => HeaderType::CARD_BUS,
10503
10504 crate::natural::HeaderType::Mask => HeaderType::MASK,
10505
10506 crate::natural::HeaderType::MultiFn => HeaderType::MULTI_FN,
10507
10508 crate::natural::HeaderType::UnknownOrdinal_(value) => {
10509 HeaderType { value: u8::from(value) }
10510 }
10511 }
10512 }
10513 }
10514
10515 impl ::fidl_next::IntoNatural for HeaderType {
10516 type Natural = crate::natural::HeaderType;
10517 }
10518
10519 #[derive(Clone, Copy, Debug)]
10521 #[repr(transparent)]
10522 pub struct Status {
10523 pub(crate) value: ::fidl_next::wire::Uint16,
10524 }
10525
10526 impl ::fidl_next::Constrained for Status {
10527 type Constraint = ();
10528
10529 fn validate(
10530 _: ::fidl_next::Slot<'_, Self>,
10531 _: Self::Constraint,
10532 ) -> Result<(), ::fidl_next::ValidationError> {
10533 Ok(())
10534 }
10535 }
10536
10537 unsafe impl ::fidl_next::Wire for Status {
10538 type Narrowed<'de> = Self;
10539
10540 #[inline]
10541 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10542 }
10544 }
10545
10546 unsafe impl<___D> ::fidl_next::Decode<___D> for Status
10547 where
10548 ___D: ?Sized,
10549 {
10550 fn decode(
10551 slot: ::fidl_next::Slot<'_, Self>,
10552 _: &mut ___D,
10553 _: (),
10554 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10555 Ok(())
10556 }
10557 }
10558
10559 impl ::core::convert::From<crate::natural::Status> for Status {
10560 fn from(natural: crate::natural::Status) -> Self {
10561 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
10562 }
10563 }
10564
10565 impl ::fidl_next::IntoNatural for Status {
10566 type Natural = crate::natural::Status;
10567 }
10568}
10569
10570pub mod wire_optional {}
10571
10572pub mod generic {
10573
10574 pub struct Address<T0, T1, T2> {
10576 pub bus: T0,
10577
10578 pub device: T1,
10579
10580 pub function: T2,
10581 }
10582
10583 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Address, ___E>
10584 for Address<T0, T1, T2>
10585 where
10586 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10587 T0: ::fidl_next::Encode<u8, ___E>,
10588 T1: ::fidl_next::Encode<u8, ___E>,
10589 T2: ::fidl_next::Encode<u8, ___E>,
10590 {
10591 #[inline]
10592 fn encode(
10593 self,
10594 encoder_: &mut ___E,
10595 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
10596 _: (),
10597 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10598 ::fidl_next::munge! {
10599 let crate::wire::Address {
10600 bus,
10601 device,
10602 function,
10603
10604 } = out_;
10605 }
10606
10607 ::fidl_next::Encode::encode(self.bus, encoder_, bus, ())?;
10608
10609 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
10610
10611 ::fidl_next::Encode::encode(self.function, encoder_, function, ())?;
10612
10613 Ok(())
10614 }
10615 }
10616
10617 pub struct BaseAddress<T0, T1, T2, T3, T4, T5> {
10619 pub address: T0,
10620
10621 pub size: T1,
10622
10623 pub is_memory: T2,
10624
10625 pub is_prefetchable: T3,
10626
10627 pub is_64bit: T4,
10628
10629 pub id: T5,
10630 }
10631
10632 unsafe impl<___E, T0, T1, T2, T3, T4, T5> ::fidl_next::Encode<crate::wire::BaseAddress, ___E>
10633 for BaseAddress<T0, T1, T2, T3, T4, T5>
10634 where
10635 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10636 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10637 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10638 T2: ::fidl_next::Encode<bool, ___E>,
10639 T3: ::fidl_next::Encode<bool, ___E>,
10640 T4: ::fidl_next::Encode<bool, ___E>,
10641 T5: ::fidl_next::Encode<u8, ___E>,
10642 {
10643 #[inline]
10644 fn encode(
10645 self,
10646 encoder_: &mut ___E,
10647 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
10648 _: (),
10649 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10650 ::fidl_next::munge! {
10651 let crate::wire::BaseAddress {
10652 address,
10653 size,
10654 is_memory,
10655 is_prefetchable,
10656 is_64bit,
10657 id,
10658
10659 } = out_;
10660 }
10661
10662 ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;
10663
10664 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10665
10666 ::fidl_next::Encode::encode(self.is_memory, encoder_, is_memory, ())?;
10667
10668 ::fidl_next::Encode::encode(self.is_prefetchable, encoder_, is_prefetchable, ())?;
10669
10670 ::fidl_next::Encode::encode(self.is_64bit, encoder_, is_64bit, ())?;
10671
10672 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10673
10674 Ok(())
10675 }
10676 }
10677
10678 pub type UseIntxWorkaroundType = ();
10680
10681 pub struct HostBridgeInfo<T0, T1, T2, T3> {
10683 pub name: T0,
10684
10685 pub start_bus_number: T1,
10686
10687 pub end_bus_number: T2,
10688
10689 pub segment_group: T3,
10690 }
10691
10692 unsafe impl<___E, T0, T1, T2, T3>
10693 ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
10694 for HostBridgeInfo<T0, T1, T2, T3>
10695 where
10696 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10697 ___E: ::fidl_next::Encoder,
10698 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10699 T1: ::fidl_next::Encode<u8, ___E>,
10700 T2: ::fidl_next::Encode<u8, ___E>,
10701 T3: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10702 {
10703 #[inline]
10704 fn encode(
10705 self,
10706 encoder_: &mut ___E,
10707 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
10708 _: (),
10709 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10710 ::fidl_next::munge! {
10711 let crate::wire::HostBridgeInfo {
10712 name,
10713 start_bus_number,
10714 end_bus_number,
10715 segment_group,
10716
10717 } = out_;
10718 }
10719
10720 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
10721
10722 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
10723
10724 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
10725
10726 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
10727
10728 Ok(())
10729 }
10730 }
10731
10732 pub struct BusGetHostBridgeInfoResponse<T0> {
10734 pub info: T0,
10735 }
10736
10737 unsafe impl<___E, T0>
10738 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
10739 for BusGetHostBridgeInfoResponse<T0>
10740 where
10741 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10742 ___E: ::fidl_next::Encoder,
10743 T0: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
10744 {
10745 #[inline]
10746 fn encode(
10747 self,
10748 encoder_: &mut ___E,
10749 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
10750 _: (),
10751 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10752 ::fidl_next::munge! {
10753 let crate::wire::BusGetHostBridgeInfoResponse {
10754 info,
10755
10756 } = out_;
10757 }
10758
10759 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
10760
10761 Ok(())
10762 }
10763 }
10764
10765 pub struct Capability<T0, T1> {
10767 pub id: T0,
10768
10769 pub offset: T1,
10770 }
10771
10772 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability<T0, T1>
10773 where
10774 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10775 T0: ::fidl_next::Encode<u8, ___E>,
10776 T1: ::fidl_next::Encode<u8, ___E>,
10777 {
10778 #[inline]
10779 fn encode(
10780 self,
10781 encoder_: &mut ___E,
10782 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
10783 _: (),
10784 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10785 ::fidl_next::munge! {
10786 let crate::wire::Capability {
10787 id,
10788 offset,
10789
10790 } = out_;
10791 }
10792
10793 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10794
10795 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10796
10797 Ok(())
10798 }
10799 }
10800
10801 pub struct ExtendedCapability<T0, T1> {
10803 pub id: T0,
10804
10805 pub offset: T1,
10806 }
10807
10808 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
10809 for ExtendedCapability<T0, T1>
10810 where
10811 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10812 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10813 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10814 {
10815 #[inline]
10816 fn encode(
10817 self,
10818 encoder_: &mut ___E,
10819 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
10820 _: (),
10821 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10822 ::fidl_next::munge! {
10823 let crate::wire::ExtendedCapability {
10824 id,
10825 offset,
10826
10827 } = out_;
10828 }
10829
10830 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10831
10832 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10833
10834 Ok(())
10835 }
10836 }
10837
10838 pub struct PciDevice<T0, T1, T2, T3, T4, T5, T6> {
10840 pub base_addresses: T0,
10841
10842 pub capabilities: T1,
10843
10844 pub ext_capabilities: T2,
10845
10846 pub config: T3,
10847
10848 pub bus_id: T4,
10849
10850 pub device_id: T5,
10851
10852 pub function_id: T6,
10853 }
10854
10855 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
10856 ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>
10857 for PciDevice<T0, T1, T2, T3, T4, T5, T6>
10858 where
10859 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10860 ___E: ::fidl_next::Encoder,
10861 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::BaseAddress>, ___E>,
10862 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::Capability>, ___E>,
10863 T2: ::fidl_next::Encode<
10864 ::fidl_next::wire::Vector<'static, crate::wire::ExtendedCapability>,
10865 ___E,
10866 >,
10867 T3: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
10868 T4: ::fidl_next::Encode<u8, ___E>,
10869 T5: ::fidl_next::Encode<u8, ___E>,
10870 T6: ::fidl_next::Encode<u8, ___E>,
10871 {
10872 #[inline]
10873 fn encode(
10874 self,
10875 encoder_: &mut ___E,
10876 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
10877 _: (),
10878 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10879 ::fidl_next::munge! {
10880 let crate::wire::PciDevice {
10881 base_addresses,
10882 capabilities,
10883 ext_capabilities,
10884 config,
10885 bus_id,
10886 device_id,
10887 function_id,
10888
10889 } = out_;
10890 }
10891
10892 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
10893
10894 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
10895
10896 ::fidl_next::Encode::encode(
10897 self.ext_capabilities,
10898 encoder_,
10899 ext_capabilities,
10900 (32, ()),
10901 )?;
10902
10903 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
10904
10905 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
10906
10907 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
10908
10909 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
10910
10911 Ok(())
10912 }
10913 }
10914
10915 pub struct BusGetDevicesResponse<T0> {
10917 pub devices: T0,
10918 }
10919
10920 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
10921 for BusGetDevicesResponse<T0>
10922 where
10923 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10924 ___E: ::fidl_next::Encoder,
10925 T0: ::fidl_next::Encode<
10926 ::fidl_next::wire::Vector<'static, crate::wire::PciDevice<'static>>,
10927 ___E,
10928 >,
10929 {
10930 #[inline]
10931 fn encode(
10932 self,
10933 encoder_: &mut ___E,
10934 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
10935 _: (),
10936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10937 ::fidl_next::munge! {
10938 let crate::wire::BusGetDevicesResponse {
10939 devices,
10940
10941 } = out_;
10942 }
10943
10944 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
10945
10946 Ok(())
10947 }
10948 }
10949
10950 pub struct BusReadBarRequest<T0, T1, T2, T3> {
10952 pub device: T0,
10953
10954 pub bar_id: T1,
10955
10956 pub offset: T2,
10957
10958 pub size: T3,
10959 }
10960
10961 unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>
10962 for BusReadBarRequest<T0, T1, T2, T3>
10963 where
10964 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10965 T0: ::fidl_next::Encode<crate::wire::Address, ___E>,
10966 T1: ::fidl_next::Encode<u8, ___E>,
10967 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10968 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10969 {
10970 #[inline]
10971 fn encode(
10972 self,
10973 encoder_: &mut ___E,
10974 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
10975 _: (),
10976 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10977 ::fidl_next::munge! {
10978 let crate::wire::BusReadBarRequest {
10979 device,
10980 bar_id,
10981 offset,
10982 size,
10983
10984 } = out_;
10985 }
10986
10987 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
10988
10989 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
10990
10991 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10992
10993 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10994
10995 Ok(())
10996 }
10997 }
10998
10999 pub struct BusReadBarResponse<T0> {
11001 pub buffer: T0,
11002 }
11003
11004 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
11005 for BusReadBarResponse<T0>
11006 where
11007 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11008 ___E: ::fidl_next::Encoder,
11009 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11010 {
11011 #[inline]
11012 fn encode(
11013 self,
11014 encoder_: &mut ___E,
11015 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
11016 _: (),
11017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11018 ::fidl_next::munge! {
11019 let crate::wire::BusReadBarResponse {
11020 buffer,
11021
11022 } = out_;
11023 }
11024
11025 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
11026
11027 Ok(())
11028 }
11029 }
11030
11031 pub type Padding = ();
11033
11034 pub struct DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
11036 pub vendor_id: T0,
11037
11038 pub device_id: T1,
11039
11040 pub base_class: T2,
11041
11042 pub sub_class: T3,
11043
11044 pub program_interface: T4,
11045
11046 pub revision_id: T5,
11047
11048 pub bus_id: T6,
11049
11050 pub dev_id: T7,
11051
11052 pub func_id: T8,
11053
11054 pub padding: T9,
11055 }
11056
11057 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11058 ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>
11059 for DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11060 where
11061 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11062 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11063 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11064 T2: ::fidl_next::Encode<u8, ___E>,
11065 T3: ::fidl_next::Encode<u8, ___E>,
11066 T4: ::fidl_next::Encode<u8, ___E>,
11067 T5: ::fidl_next::Encode<u8, ___E>,
11068 T6: ::fidl_next::Encode<u8, ___E>,
11069 T7: ::fidl_next::Encode<u8, ___E>,
11070 T8: ::fidl_next::Encode<u8, ___E>,
11071 T9: ::fidl_next::Encode<crate::wire::Padding, ___E>,
11072 {
11073 #[inline]
11074 fn encode(
11075 self,
11076 encoder_: &mut ___E,
11077 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
11078 _: (),
11079 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11080 ::fidl_next::munge! {
11081 let crate::wire::DeviceInfo {
11082 vendor_id,
11083 device_id,
11084 base_class,
11085 sub_class,
11086 program_interface,
11087 revision_id,
11088 bus_id,
11089 dev_id,
11090 func_id,
11091 padding,
11092
11093 } = out_;
11094 }
11095
11096 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
11097
11098 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11099
11100 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
11101
11102 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
11103
11104 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
11105
11106 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
11107
11108 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11109
11110 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
11111
11112 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
11113
11114 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
11115
11116 Ok(())
11117 }
11118 }
11119
11120 pub struct DeviceGetDeviceInfoResponse<T0> {
11122 pub info: T0,
11123 }
11124
11125 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
11126 for DeviceGetDeviceInfoResponse<T0>
11127 where
11128 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11129 T0: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
11130 {
11131 #[inline]
11132 fn encode(
11133 self,
11134 encoder_: &mut ___E,
11135 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
11136 _: (),
11137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11138 ::fidl_next::munge! {
11139 let crate::wire::DeviceGetDeviceInfoResponse {
11140 info,
11141
11142 } = out_;
11143 }
11144
11145 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
11146
11147 Ok(())
11148 }
11149 }
11150
11151 pub struct DeviceGetBarRequest<T0> {
11153 pub bar_id: T0,
11154 }
11155
11156 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
11157 for DeviceGetBarRequest<T0>
11158 where
11159 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11160 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11161 {
11162 #[inline]
11163 fn encode(
11164 self,
11165 encoder_: &mut ___E,
11166 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
11167 _: (),
11168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11169 ::fidl_next::munge! {
11170 let crate::wire::DeviceGetBarRequest {
11171 bar_id,
11172
11173 } = out_;
11174 }
11175
11176 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11177
11178 Ok(())
11179 }
11180 }
11181
11182 pub struct DeviceSetBusMasteringRequest<T0> {
11184 pub enabled: T0,
11185 }
11186
11187 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
11188 for DeviceSetBusMasteringRequest<T0>
11189 where
11190 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11191 T0: ::fidl_next::Encode<bool, ___E>,
11192 {
11193 #[inline]
11194 fn encode(
11195 self,
11196 encoder_: &mut ___E,
11197 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
11198 _: (),
11199 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11200 ::fidl_next::munge! {
11201 let crate::wire::DeviceSetBusMasteringRequest {
11202 enabled,
11203
11204 } = out_;
11205 }
11206
11207 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
11208
11209 Ok(())
11210 }
11211 }
11212
11213 pub type DeviceSetBusMasteringResponse = ();
11215
11216 pub type DeviceResetDeviceResponse = ();
11218
11219 pub type DeviceAckInterruptResponse = ();
11221
11222 pub struct DeviceMapInterruptRequest<T0> {
11224 pub which_irq: T0,
11225 }
11226
11227 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
11228 for DeviceMapInterruptRequest<T0>
11229 where
11230 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11231 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11232 {
11233 #[inline]
11234 fn encode(
11235 self,
11236 encoder_: &mut ___E,
11237 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
11238 _: (),
11239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11240 ::fidl_next::munge! {
11241 let crate::wire::DeviceMapInterruptRequest {
11242 which_irq,
11243
11244 } = out_;
11245 }
11246
11247 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
11248
11249 Ok(())
11250 }
11251 }
11252
11253 pub struct InterruptModes<T0, T1, T2> {
11255 pub has_legacy: T0,
11256
11257 pub msi_count: T1,
11258
11259 pub msix_count: T2,
11260 }
11261
11262 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::InterruptModes, ___E>
11263 for InterruptModes<T0, T1, T2>
11264 where
11265 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11266 T0: ::fidl_next::Encode<bool, ___E>,
11267 T1: ::fidl_next::Encode<u8, ___E>,
11268 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11269 {
11270 #[inline]
11271 fn encode(
11272 self,
11273 encoder_: &mut ___E,
11274 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
11275 _: (),
11276 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11277 ::fidl_next::munge! {
11278 let crate::wire::InterruptModes {
11279 has_legacy,
11280 msi_count,
11281 msix_count,
11282
11283 } = out_;
11284 }
11285
11286 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
11287
11288 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
11289
11290 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
11291
11292 Ok(())
11293 }
11294 }
11295
11296 pub struct DeviceGetInterruptModesResponse<T0> {
11298 pub modes: T0,
11299 }
11300
11301 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
11302 for DeviceGetInterruptModesResponse<T0>
11303 where
11304 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11305 T0: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
11306 {
11307 #[inline]
11308 fn encode(
11309 self,
11310 encoder_: &mut ___E,
11311 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
11312 _: (),
11313 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11314 ::fidl_next::munge! {
11315 let crate::wire::DeviceGetInterruptModesResponse {
11316 modes,
11317
11318 } = out_;
11319 }
11320
11321 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
11322
11323 Ok(())
11324 }
11325 }
11326
11327 pub type DeviceSetInterruptModeResponse = ();
11329
11330 pub struct DeviceReadConfig8Request<T0> {
11332 pub offset: T0,
11333 }
11334
11335 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
11336 for DeviceReadConfig8Request<T0>
11337 where
11338 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11339 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11340 {
11341 #[inline]
11342 fn encode(
11343 self,
11344 encoder_: &mut ___E,
11345 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
11346 _: (),
11347 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11348 ::fidl_next::munge! {
11349 let crate::wire::DeviceReadConfig8Request {
11350 offset,
11351
11352 } = out_;
11353 }
11354
11355 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11356
11357 Ok(())
11358 }
11359 }
11360
11361 pub struct DeviceReadConfig8Response<T0> {
11363 pub value: T0,
11364 }
11365
11366 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
11367 for DeviceReadConfig8Response<T0>
11368 where
11369 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11370 T0: ::fidl_next::Encode<u8, ___E>,
11371 {
11372 #[inline]
11373 fn encode(
11374 self,
11375 encoder_: &mut ___E,
11376 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
11377 _: (),
11378 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11379 ::fidl_next::munge! {
11380 let crate::wire::DeviceReadConfig8Response {
11381 value,
11382
11383 } = out_;
11384 }
11385
11386 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11387
11388 Ok(())
11389 }
11390 }
11391
11392 pub struct DeviceReadConfig16Request<T0> {
11394 pub offset: T0,
11395 }
11396
11397 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
11398 for DeviceReadConfig16Request<T0>
11399 where
11400 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11401 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11402 {
11403 #[inline]
11404 fn encode(
11405 self,
11406 encoder_: &mut ___E,
11407 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
11408 _: (),
11409 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11410 ::fidl_next::munge! {
11411 let crate::wire::DeviceReadConfig16Request {
11412 offset,
11413
11414 } = out_;
11415 }
11416
11417 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11418
11419 Ok(())
11420 }
11421 }
11422
11423 pub struct DeviceReadConfig16Response<T0> {
11425 pub value: T0,
11426 }
11427
11428 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
11429 for DeviceReadConfig16Response<T0>
11430 where
11431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11432 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11433 {
11434 #[inline]
11435 fn encode(
11436 self,
11437 encoder_: &mut ___E,
11438 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
11439 _: (),
11440 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11441 ::fidl_next::munge! {
11442 let crate::wire::DeviceReadConfig16Response {
11443 value,
11444
11445 } = out_;
11446 }
11447
11448 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11449
11450 Ok(())
11451 }
11452 }
11453
11454 pub struct DeviceReadConfig32Request<T0> {
11456 pub offset: T0,
11457 }
11458
11459 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
11460 for DeviceReadConfig32Request<T0>
11461 where
11462 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11463 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11464 {
11465 #[inline]
11466 fn encode(
11467 self,
11468 encoder_: &mut ___E,
11469 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
11470 _: (),
11471 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11472 ::fidl_next::munge! {
11473 let crate::wire::DeviceReadConfig32Request {
11474 offset,
11475
11476 } = out_;
11477 }
11478
11479 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11480
11481 Ok(())
11482 }
11483 }
11484
11485 pub struct DeviceReadConfig32Response<T0> {
11487 pub value: T0,
11488 }
11489
11490 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
11491 for DeviceReadConfig32Response<T0>
11492 where
11493 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11494 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11495 {
11496 #[inline]
11497 fn encode(
11498 self,
11499 encoder_: &mut ___E,
11500 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
11501 _: (),
11502 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11503 ::fidl_next::munge! {
11504 let crate::wire::DeviceReadConfig32Response {
11505 value,
11506
11507 } = out_;
11508 }
11509
11510 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11511
11512 Ok(())
11513 }
11514 }
11515
11516 pub struct DeviceWriteConfig8Request<T0, T1> {
11518 pub offset: T0,
11519
11520 pub value: T1,
11521 }
11522
11523 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
11524 for DeviceWriteConfig8Request<T0, T1>
11525 where
11526 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11527 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11528 T1: ::fidl_next::Encode<u8, ___E>,
11529 {
11530 #[inline]
11531 fn encode(
11532 self,
11533 encoder_: &mut ___E,
11534 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
11535 _: (),
11536 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11537 ::fidl_next::munge! {
11538 let crate::wire::DeviceWriteConfig8Request {
11539 offset,
11540 value,
11541
11542 } = out_;
11543 }
11544
11545 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11546
11547 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11548
11549 Ok(())
11550 }
11551 }
11552
11553 pub type DeviceWriteConfig8Response = ();
11555
11556 pub struct DeviceWriteConfig16Request<T0, T1> {
11558 pub offset: T0,
11559
11560 pub value: T1,
11561 }
11562
11563 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
11564 for DeviceWriteConfig16Request<T0, T1>
11565 where
11566 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11567 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11568 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11569 {
11570 #[inline]
11571 fn encode(
11572 self,
11573 encoder_: &mut ___E,
11574 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
11575 _: (),
11576 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11577 ::fidl_next::munge! {
11578 let crate::wire::DeviceWriteConfig16Request {
11579 offset,
11580 value,
11581
11582 } = out_;
11583 }
11584
11585 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11586
11587 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11588
11589 Ok(())
11590 }
11591 }
11592
11593 pub type DeviceWriteConfig16Response = ();
11595
11596 pub struct DeviceWriteConfig32Request<T0, T1> {
11598 pub offset: T0,
11599
11600 pub value: T1,
11601 }
11602
11603 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
11604 for DeviceWriteConfig32Request<T0, T1>
11605 where
11606 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11607 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11608 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11609 {
11610 #[inline]
11611 fn encode(
11612 self,
11613 encoder_: &mut ___E,
11614 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
11615 _: (),
11616 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11617 ::fidl_next::munge! {
11618 let crate::wire::DeviceWriteConfig32Request {
11619 offset,
11620 value,
11621
11622 } = out_;
11623 }
11624
11625 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11626
11627 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11628
11629 Ok(())
11630 }
11631 }
11632
11633 pub type DeviceWriteConfig32Response = ();
11635
11636 pub struct DeviceGetCapabilitiesRequest<T0> {
11638 pub id: T0,
11639 }
11640
11641 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
11642 for DeviceGetCapabilitiesRequest<T0>
11643 where
11644 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11645 T0: ::fidl_next::Encode<crate::wire::CapabilityId, ___E>,
11646 {
11647 #[inline]
11648 fn encode(
11649 self,
11650 encoder_: &mut ___E,
11651 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
11652 _: (),
11653 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11654 ::fidl_next::munge! {
11655 let crate::wire::DeviceGetCapabilitiesRequest {
11656 id,
11657
11658 } = out_;
11659 }
11660
11661 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11662
11663 Ok(())
11664 }
11665 }
11666
11667 pub struct DeviceGetCapabilitiesResponse<T0> {
11669 pub offsets: T0,
11670 }
11671
11672 unsafe impl<___E, T0>
11673 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
11674 for DeviceGetCapabilitiesResponse<T0>
11675 where
11676 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11677 ___E: ::fidl_next::Encoder,
11678 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11679 {
11680 #[inline]
11681 fn encode(
11682 self,
11683 encoder_: &mut ___E,
11684 out_: &mut ::core::mem::MaybeUninit<
11685 crate::wire::DeviceGetCapabilitiesResponse<'static>,
11686 >,
11687 _: (),
11688 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11689 ::fidl_next::munge! {
11690 let crate::wire::DeviceGetCapabilitiesResponse {
11691 offsets,
11692
11693 } = out_;
11694 }
11695
11696 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11697
11698 Ok(())
11699 }
11700 }
11701
11702 pub struct DeviceGetExtendedCapabilitiesRequest<T0> {
11704 pub id: T0,
11705 }
11706
11707 unsafe impl<___E, T0>
11708 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
11709 for DeviceGetExtendedCapabilitiesRequest<T0>
11710 where
11711 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11712 T0: ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>,
11713 {
11714 #[inline]
11715 fn encode(
11716 self,
11717 encoder_: &mut ___E,
11718 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
11719 _: (),
11720 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11721 ::fidl_next::munge! {
11722 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
11723 id,
11724
11725 } = out_;
11726 }
11727
11728 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11729
11730 Ok(())
11731 }
11732 }
11733
11734 pub struct DeviceGetExtendedCapabilitiesResponse<T0> {
11736 pub offsets: T0,
11737 }
11738
11739 unsafe impl<___E, T0>
11740 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
11741 for DeviceGetExtendedCapabilitiesResponse<T0>
11742 where
11743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11744 ___E: ::fidl_next::Encoder,
11745 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>, ___E>,
11746 {
11747 #[inline]
11748 fn encode(
11749 self,
11750 encoder_: &mut ___E,
11751 out_: &mut ::core::mem::MaybeUninit<
11752 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
11753 >,
11754 _: (),
11755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11756 ::fidl_next::munge! {
11757 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
11758 offsets,
11759
11760 } = out_;
11761 }
11762
11763 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11764
11765 Ok(())
11766 }
11767 }
11768
11769 pub struct DeviceGetBtiRequest<T0> {
11771 pub index: T0,
11772 }
11773
11774 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
11775 for DeviceGetBtiRequest<T0>
11776 where
11777 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11778 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11779 {
11780 #[inline]
11781 fn encode(
11782 self,
11783 encoder_: &mut ___E,
11784 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
11785 _: (),
11786 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11787 ::fidl_next::munge! {
11788 let crate::wire::DeviceGetBtiRequest {
11789 index,
11790
11791 } = out_;
11792 }
11793
11794 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
11795
11796 Ok(())
11797 }
11798 }
11799
11800 pub struct DeviceSetInterruptModeRequest<T0, T1> {
11802 pub mode: T0,
11803
11804 pub requested_irq_count: T1,
11805 }
11806
11807 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
11808 for DeviceSetInterruptModeRequest<T0, T1>
11809 where
11810 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11811 T0: ::fidl_next::Encode<crate::wire::InterruptMode, ___E>,
11812 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11813 {
11814 #[inline]
11815 fn encode(
11816 self,
11817 encoder_: &mut ___E,
11818 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
11819 _: (),
11820 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11821 ::fidl_next::munge! {
11822 let crate::wire::DeviceSetInterruptModeRequest {
11823 mode,
11824 requested_irq_count,
11825
11826 } = out_;
11827 }
11828
11829 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
11830
11831 ::fidl_next::Encode::encode(
11832 self.requested_irq_count,
11833 encoder_,
11834 requested_irq_count,
11835 (),
11836 )?;
11837
11838 Ok(())
11839 }
11840 }
11841}
11842
11843pub use self::natural::*;
11844
11845pub const BASE_ADDRESS_COUNT: u32 = 6 as u32;
11846
11847pub const BASE_CONFIG_SIZE: u32 = 256 as u32;
11848
11849pub const MAX_NAME_LEN: u32 = 32 as u32;
11850
11851pub const MAX_CAPABILITIES: u32 = 32 as u32;
11852
11853pub const MAX_EXT_CAPABILITIES: u32 = 32 as u32;
11854
11855pub const MAX_DEVICES: u32 = 64 as u32;
11856
11857#[doc = " The Bus protocol provides information about PCI device children on the PCI\n providing the service.\n"]
11859#[derive(PartialEq, Debug)]
11860pub struct Bus;
11861
11862impl ::fidl_next::Discoverable for Bus {
11863 const PROTOCOL_NAME: &'static str = "fuchsia.hardware.pci.Bus";
11864}
11865
11866#[cfg(target_os = "fuchsia")]
11867impl ::fidl_next::HasTransport for Bus {
11868 type Transport = ::fidl_next::fuchsia::zx::Channel;
11869}
11870
11871pub mod bus {
11872 pub mod prelude {
11873 pub use crate::{
11874 Bus, BusClientHandler, BusLocalClientHandler, BusLocalServerHandler, BusServerHandler,
11875 bus,
11876 };
11877
11878 pub use crate::natural::BusGetDevicesResponse;
11879
11880 pub use crate::natural::BusGetHostBridgeInfoResponse;
11881
11882 pub use crate::natural::BusReadBarRequest;
11883
11884 pub use crate::natural::BusReadBarResponse;
11885 }
11886
11887 pub struct GetHostBridgeInfo;
11888
11889 impl ::fidl_next::Method for GetHostBridgeInfo {
11890 const ORDINAL: u64 = 4175032687054816861;
11891 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11892 ::fidl_next::protocol::Flexibility::Strict;
11893
11894 type Protocol = crate::Bus;
11895
11896 type Request = ::fidl_next::wire::EmptyMessageBody;
11897 }
11898
11899 impl ::fidl_next::TwoWayMethod for GetHostBridgeInfo {
11900 type Response = crate::wire::BusGetHostBridgeInfoResponse<'static>;
11901 }
11902
11903 impl<___R> ::fidl_next::Respond<___R> for GetHostBridgeInfo {
11904 type Output = crate::generic::BusGetHostBridgeInfoResponse<___R>;
11905
11906 fn respond(response: ___R) -> Self::Output {
11907 crate::generic::BusGetHostBridgeInfoResponse { info: response }
11908 }
11909 }
11910
11911 pub struct GetDevices;
11912
11913 impl ::fidl_next::Method for GetDevices {
11914 const ORDINAL: u64 = 3114700014429961362;
11915 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11916 ::fidl_next::protocol::Flexibility::Strict;
11917
11918 type Protocol = crate::Bus;
11919
11920 type Request = ::fidl_next::wire::EmptyMessageBody;
11921 }
11922
11923 impl ::fidl_next::TwoWayMethod for GetDevices {
11924 type Response = crate::wire::BusGetDevicesResponse<'static>;
11925 }
11926
11927 impl<___R> ::fidl_next::Respond<___R> for GetDevices {
11928 type Output = crate::generic::BusGetDevicesResponse<___R>;
11929
11930 fn respond(response: ___R) -> Self::Output {
11931 crate::generic::BusGetDevicesResponse { devices: response }
11932 }
11933 }
11934
11935 pub struct ReadBar;
11936
11937 impl ::fidl_next::Method for ReadBar {
11938 const ORDINAL: u64 = 8759283232091687008;
11939 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11940 ::fidl_next::protocol::Flexibility::Strict;
11941
11942 type Protocol = crate::Bus;
11943
11944 type Request = crate::wire::BusReadBarRequest;
11945 }
11946
11947 impl ::fidl_next::TwoWayMethod for ReadBar {
11948 type Response = ::fidl_next::wire::Result<
11949 'static,
11950 crate::wire::BusReadBarResponse<'static>,
11951 ::fidl_next::wire::Int32,
11952 >;
11953 }
11954
11955 impl<___R> ::fidl_next::Respond<___R> for ReadBar {
11956 type Output = ::core::result::Result<
11957 crate::generic::BusReadBarResponse<___R>,
11958 ::fidl_next::util::Never,
11959 >;
11960
11961 fn respond(response: ___R) -> Self::Output {
11962 ::core::result::Result::Ok(crate::generic::BusReadBarResponse { buffer: response })
11963 }
11964 }
11965
11966 impl<___R> ::fidl_next::RespondErr<___R> for ReadBar {
11967 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11968
11969 fn respond_err(response: ___R) -> Self::Output {
11970 ::core::result::Result::Err(response)
11971 }
11972 }
11973
11974 mod ___detail {
11975 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Bus
11976 where
11977 ___T: ::fidl_next::Transport,
11978 {
11979 type Client = BusClient<___T>;
11980 type Server = BusServer<___T>;
11981 }
11982
11983 #[repr(transparent)]
11985 pub struct BusClient<___T: ::fidl_next::Transport> {
11986 #[allow(dead_code)]
11987 client: ::fidl_next::protocol::Client<___T>,
11988 }
11989
11990 impl<___T> BusClient<___T>
11991 where
11992 ___T: ::fidl_next::Transport,
11993 {
11994 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
11995 pub fn get_host_bridge_info(
11996 &self,
11997 ) -> ::fidl_next::TwoWayFuture<'_, super::GetHostBridgeInfo, ___T> {
11998 ::fidl_next::TwoWayFuture::from_untyped(
11999 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12000 4175032687054816861,
12001 <super::GetHostBridgeInfo as ::fidl_next::Method>::FLEXIBILITY,
12002 (),
12003 ),
12004 )
12005 }
12006
12007 #[doc = " Retrieve all Devices on the Bus.\n"]
12008 pub fn get_devices(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetDevices, ___T> {
12009 ::fidl_next::TwoWayFuture::from_untyped(
12010 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12011 3114700014429961362,
12012 <super::GetDevices as ::fidl_next::Method>::FLEXIBILITY,
12013 (),
12014 ),
12015 )
12016 }
12017
12018 #[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"]
12019 pub fn read_bar(
12020 &self,
12021
12022 device: impl ::fidl_next::Encode<
12023 crate::wire::Address,
12024 <___T as ::fidl_next::Transport>::SendBuffer,
12025 >,
12026
12027 bar_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
12028
12029 offset: impl ::fidl_next::Encode<
12030 ::fidl_next::wire::Uint64,
12031 <___T as ::fidl_next::Transport>::SendBuffer,
12032 >,
12033
12034 size: impl ::fidl_next::Encode<
12035 ::fidl_next::wire::Uint64,
12036 <___T as ::fidl_next::Transport>::SendBuffer,
12037 >,
12038 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12039 where
12040 <___T as ::fidl_next::Transport>::SendBuffer:
12041 ::fidl_next::encoder::InternalHandleEncoder,
12042 {
12043 self.read_bar_with(crate::generic::BusReadBarRequest {
12044 device,
12045
12046 bar_id,
12047
12048 offset,
12049
12050 size,
12051 })
12052 }
12053
12054 #[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"]
12055 pub fn read_bar_with<___R>(
12056 &self,
12057 request: ___R,
12058 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12059 where
12060 ___R: ::fidl_next::Encode<
12061 crate::wire::BusReadBarRequest,
12062 <___T as ::fidl_next::Transport>::SendBuffer,
12063 >,
12064 {
12065 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12066 8759283232091687008,
12067 <super::ReadBar as ::fidl_next::Method>::FLEXIBILITY,
12068 request,
12069 ))
12070 }
12071 }
12072
12073 #[repr(transparent)]
12075 pub struct BusServer<___T: ::fidl_next::Transport> {
12076 server: ::fidl_next::protocol::Server<___T>,
12077 }
12078
12079 impl<___T> BusServer<___T> where ___T: ::fidl_next::Transport {}
12080 }
12081}
12082
12083#[diagnostic::on_unimplemented(
12084 note = "If {Self} implements the non-local BusClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12085)]
12086
12087pub trait BusLocalClientHandler<
12091 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12092 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12093>
12094{
12095}
12096
12097impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Bus
12098where
12099 ___H: BusLocalClientHandler<___T>,
12100 ___T: ::fidl_next::Transport,
12101{
12102 async fn on_event(
12103 handler: &mut ___H,
12104 ordinal: u64,
12105 flexibility: ::fidl_next::protocol::Flexibility,
12106 body: ::fidl_next::Body<___T>,
12107 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12108 match ordinal {
12109 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12110 }
12111 }
12112}
12113
12114#[diagnostic::on_unimplemented(
12115 note = "If {Self} implements the non-local BusServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12116)]
12117
12118pub trait BusLocalServerHandler<
12122 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12123 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12124>
12125{
12126 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12127 fn get_host_bridge_info(
12128 &mut self,
12129
12130 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12131 ) -> impl ::core::future::Future<Output = ()>;
12132
12133 #[doc = " Retrieve all Devices on the Bus.\n"]
12134 fn get_devices(
12135 &mut self,
12136
12137 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12138 ) -> impl ::core::future::Future<Output = ()>;
12139
12140 #[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"]
12141 fn read_bar(
12142 &mut self,
12143
12144 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12145
12146 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12147 ) -> impl ::core::future::Future<Output = ()>;
12148}
12149
12150impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Bus
12151where
12152 ___H: BusLocalServerHandler<___T>,
12153 ___T: ::fidl_next::Transport,
12154 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12155 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12156 Constraint = (),
12157 >,
12158{
12159 async fn on_one_way(
12160 handler: &mut ___H,
12161 ordinal: u64,
12162 flexibility: ::fidl_next::protocol::Flexibility,
12163 body: ::fidl_next::Body<___T>,
12164 ) -> ::core::result::Result<
12165 (),
12166 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12167 > {
12168 match ordinal {
12169 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12170 }
12171 }
12172
12173 async fn on_two_way(
12174 handler: &mut ___H,
12175 ordinal: u64,
12176 flexibility: ::fidl_next::protocol::Flexibility,
12177 body: ::fidl_next::Body<___T>,
12178 responder: ::fidl_next::protocol::Responder<___T>,
12179 ) -> ::core::result::Result<
12180 (),
12181 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12182 > {
12183 match ordinal {
12184 4175032687054816861 => {
12185 let responder = ::fidl_next::Responder::from_untyped(responder);
12186
12187 handler.get_host_bridge_info(responder).await;
12188 Ok(())
12189 }
12190
12191 3114700014429961362 => {
12192 let responder = ::fidl_next::Responder::from_untyped(responder);
12193
12194 handler.get_devices(responder).await;
12195 Ok(())
12196 }
12197
12198 8759283232091687008 => {
12199 let responder = ::fidl_next::Responder::from_untyped(responder);
12200
12201 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12202 Ok(decoded) => {
12203 handler
12204 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12205 .await;
12206 Ok(())
12207 }
12208 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12209 ordinal: 8759283232091687008,
12210 error,
12211 }),
12212 }
12213 }
12214
12215 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12216 }
12217 }
12218}
12219
12220pub trait BusClientHandler<
12224 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12225 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12226>
12227{
12228}
12229
12230impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Bus
12231where
12232 ___H: BusClientHandler<___T> + ::core::marker::Send,
12233 ___T: ::fidl_next::Transport,
12234{
12235 async fn on_event(
12236 handler: &mut ___H,
12237 ordinal: u64,
12238 flexibility: ::fidl_next::protocol::Flexibility,
12239 body: ::fidl_next::Body<___T>,
12240 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12241 match ordinal {
12242 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12243 }
12244 }
12245}
12246
12247pub trait BusServerHandler<
12251 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12252 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12253>
12254{
12255 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12256 fn get_host_bridge_info(
12257 &mut self,
12258
12259 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12260 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12261
12262 #[doc = " Retrieve all Devices on the Bus.\n"]
12263 fn get_devices(
12264 &mut self,
12265
12266 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12267 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12268
12269 #[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"]
12270 fn read_bar(
12271 &mut self,
12272
12273 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12274
12275 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12276 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12277}
12278
12279impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Bus
12280where
12281 ___H: BusServerHandler<___T> + ::core::marker::Send,
12282 ___T: ::fidl_next::Transport,
12283 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12284 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12285 Constraint = (),
12286 >,
12287{
12288 async fn on_one_way(
12289 handler: &mut ___H,
12290 ordinal: u64,
12291 flexibility: ::fidl_next::protocol::Flexibility,
12292 body: ::fidl_next::Body<___T>,
12293 ) -> ::core::result::Result<
12294 (),
12295 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12296 > {
12297 match ordinal {
12298 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12299 }
12300 }
12301
12302 async fn on_two_way(
12303 handler: &mut ___H,
12304 ordinal: u64,
12305 flexibility: ::fidl_next::protocol::Flexibility,
12306 body: ::fidl_next::Body<___T>,
12307 responder: ::fidl_next::protocol::Responder<___T>,
12308 ) -> ::core::result::Result<
12309 (),
12310 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12311 > {
12312 match ordinal {
12313 4175032687054816861 => {
12314 let responder = ::fidl_next::Responder::from_untyped(responder);
12315
12316 handler.get_host_bridge_info(responder).await;
12317 Ok(())
12318 }
12319
12320 3114700014429961362 => {
12321 let responder = ::fidl_next::Responder::from_untyped(responder);
12322
12323 handler.get_devices(responder).await;
12324 Ok(())
12325 }
12326
12327 8759283232091687008 => {
12328 let responder = ::fidl_next::Responder::from_untyped(responder);
12329
12330 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12331 Ok(decoded) => {
12332 handler
12333 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12334 .await;
12335 Ok(())
12336 }
12337 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12338 ordinal: 8759283232091687008,
12339 error,
12340 }),
12341 }
12342 }
12343
12344 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12345 }
12346 }
12347}
12348
12349impl<___T> BusClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
12350
12351impl<___H, ___T> BusLocalClientHandler<___T> for ::fidl_next::Local<___H>
12352where
12353 ___H: BusClientHandler<___T>,
12354 ___T: ::fidl_next::Transport,
12355{
12356}
12357
12358impl<___H, ___T> BusLocalServerHandler<___T> for ::fidl_next::Local<___H>
12359where
12360 ___H: BusServerHandler<___T>,
12361 ___T: ::fidl_next::Transport,
12362{
12363 async fn get_host_bridge_info(
12364 &mut self,
12365
12366 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12367 ) {
12368 ___H::get_host_bridge_info(&mut self.0, responder).await
12369 }
12370
12371 async fn get_devices(&mut self, responder: ::fidl_next::Responder<bus::GetDevices, ___T>) {
12372 ___H::get_devices(&mut self.0, responder).await
12373 }
12374
12375 async fn read_bar(
12376 &mut self,
12377
12378 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12379
12380 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12381 ) {
12382 ___H::read_bar(&mut self.0, request, responder).await
12383 }
12384}
12385
12386pub const EXTENDED_CONFIG_SIZE: u32 = 4096 as u32;
12387
12388pub const MAX_BAR_COUNT: u8 = 6 as u8;
12389
12390pub const READBAR_MAX_SIZE: u32 = 1024 as u32;
12391
12392pub const STATUS_DEVSEL_MASK: crate::natural::Status =
12393 crate::natural::Status::from_bits_retain(1536);