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 pub fn take_use_intx_workaround(
7136 &mut self,
7137 ) -> ::core::option::Option<crate::wire::UseIntxWorkaroundType> {
7138 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
7139 }
7140 }
7141
7142 impl<'de> ::core::fmt::Debug for BoardConfiguration<'de> {
7143 fn fmt(
7144 &self,
7145 f: &mut ::core::fmt::Formatter<'_>,
7146 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7147 f.debug_struct("BoardConfiguration")
7148 .field("use_intx_workaround", &self.use_intx_workaround())
7149 .finish()
7150 }
7151 }
7152
7153 impl<'de> ::fidl_next::IntoNatural for BoardConfiguration<'de> {
7154 type Natural = crate::natural::BoardConfiguration;
7155 }
7156
7157 #[derive(Debug)]
7159 #[repr(C)]
7160 pub struct HostBridgeInfo<'de> {
7161 pub name: ::fidl_next::wire::String<'de>,
7162
7163 pub start_bus_number: u8,
7164
7165 pub end_bus_number: u8,
7166
7167 pub segment_group: ::fidl_next::wire::Uint16,
7168 }
7169
7170 static_assertions::const_assert_eq!(std::mem::size_of::<HostBridgeInfo<'_>>(), 24);
7171 static_assertions::const_assert_eq!(std::mem::align_of::<HostBridgeInfo<'_>>(), 8);
7172
7173 static_assertions::const_assert_eq!(std::mem::offset_of!(HostBridgeInfo<'_>, name), 0);
7174
7175 static_assertions::const_assert_eq!(
7176 std::mem::offset_of!(HostBridgeInfo<'_>, start_bus_number),
7177 16
7178 );
7179
7180 static_assertions::const_assert_eq!(
7181 std::mem::offset_of!(HostBridgeInfo<'_>, end_bus_number),
7182 17
7183 );
7184
7185 static_assertions::const_assert_eq!(
7186 std::mem::offset_of!(HostBridgeInfo<'_>, segment_group),
7187 18
7188 );
7189
7190 impl ::fidl_next::Constrained for HostBridgeInfo<'_> {
7191 type Constraint = ();
7192
7193 fn validate(
7194 _: ::fidl_next::Slot<'_, Self>,
7195 _: Self::Constraint,
7196 ) -> Result<(), ::fidl_next::ValidationError> {
7197 Ok(())
7198 }
7199 }
7200
7201 unsafe impl ::fidl_next::Wire for HostBridgeInfo<'static> {
7202 type Narrowed<'de> = HostBridgeInfo<'de>;
7203
7204 #[inline]
7205 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7206 ::fidl_next::munge! {
7207 let Self {
7208 name,
7209 start_bus_number,
7210 end_bus_number,
7211 segment_group,
7212
7213 } = &mut *out_;
7214 }
7215
7216 ::fidl_next::Wire::zero_padding(name);
7217
7218 ::fidl_next::Wire::zero_padding(start_bus_number);
7219
7220 ::fidl_next::Wire::zero_padding(end_bus_number);
7221
7222 ::fidl_next::Wire::zero_padding(segment_group);
7223
7224 unsafe {
7225 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
7226 }
7227 }
7228 }
7229
7230 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for HostBridgeInfo<'de>
7231 where
7232 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7233 ___D: ::fidl_next::Decoder<'de>,
7234 {
7235 fn decode(
7236 slot_: ::fidl_next::Slot<'_, Self>,
7237 decoder_: &mut ___D,
7238 _: (),
7239 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7240 if slot_.as_bytes()[20..24] != [0u8; 4] {
7241 return Err(::fidl_next::DecodeError::InvalidPadding);
7242 }
7243
7244 ::fidl_next::munge! {
7245 let Self {
7246 mut name,
7247 mut start_bus_number,
7248 mut end_bus_number,
7249 mut segment_group,
7250
7251 } = slot_;
7252 }
7253
7254 let _field = name.as_mut();
7255 ::fidl_next::Constrained::validate(_field, 32)?;
7256 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 32)?;
7257
7258 let name = unsafe { name.deref_unchecked() };
7259
7260 if name.len() > 32 {
7261 return Err(::fidl_next::DecodeError::VectorTooLong {
7262 size: name.len() as u64,
7263 limit: 32,
7264 });
7265 }
7266
7267 let _field = start_bus_number.as_mut();
7268
7269 ::fidl_next::Decode::decode(start_bus_number.as_mut(), decoder_, ())?;
7270
7271 let _field = end_bus_number.as_mut();
7272
7273 ::fidl_next::Decode::decode(end_bus_number.as_mut(), decoder_, ())?;
7274
7275 let _field = segment_group.as_mut();
7276
7277 ::fidl_next::Decode::decode(segment_group.as_mut(), decoder_, ())?;
7278
7279 Ok(())
7280 }
7281 }
7282
7283 impl<'de> ::fidl_next::IntoNatural for HostBridgeInfo<'de> {
7284 type Natural = crate::natural::HostBridgeInfo;
7285 }
7286
7287 #[derive(Debug)]
7289 #[repr(C)]
7290 pub struct BusGetHostBridgeInfoResponse<'de> {
7291 pub info: crate::wire::HostBridgeInfo<'de>,
7292 }
7293
7294 static_assertions::const_assert_eq!(
7295 std::mem::size_of::<BusGetHostBridgeInfoResponse<'_>>(),
7296 24
7297 );
7298 static_assertions::const_assert_eq!(
7299 std::mem::align_of::<BusGetHostBridgeInfoResponse<'_>>(),
7300 8
7301 );
7302
7303 static_assertions::const_assert_eq!(
7304 std::mem::offset_of!(BusGetHostBridgeInfoResponse<'_>, info),
7305 0
7306 );
7307
7308 impl ::fidl_next::Constrained for BusGetHostBridgeInfoResponse<'_> {
7309 type Constraint = ();
7310
7311 fn validate(
7312 _: ::fidl_next::Slot<'_, Self>,
7313 _: Self::Constraint,
7314 ) -> Result<(), ::fidl_next::ValidationError> {
7315 Ok(())
7316 }
7317 }
7318
7319 unsafe impl ::fidl_next::Wire for BusGetHostBridgeInfoResponse<'static> {
7320 type Narrowed<'de> = BusGetHostBridgeInfoResponse<'de>;
7321
7322 #[inline]
7323 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7324 ::fidl_next::munge! {
7325 let Self {
7326 info,
7327
7328 } = &mut *out_;
7329 }
7330
7331 ::fidl_next::Wire::zero_padding(info);
7332 }
7333 }
7334
7335 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetHostBridgeInfoResponse<'de>
7336 where
7337 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7338 ___D: ::fidl_next::Decoder<'de>,
7339 {
7340 fn decode(
7341 slot_: ::fidl_next::Slot<'_, Self>,
7342 decoder_: &mut ___D,
7343 _: (),
7344 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7345 ::fidl_next::munge! {
7346 let Self {
7347 mut info,
7348
7349 } = slot_;
7350 }
7351
7352 let _field = info.as_mut();
7353
7354 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
7355
7356 Ok(())
7357 }
7358 }
7359
7360 impl<'de> ::fidl_next::IntoNatural for BusGetHostBridgeInfoResponse<'de> {
7361 type Natural = crate::natural::BusGetHostBridgeInfoResponse;
7362 }
7363
7364 #[derive(Clone, Debug)]
7366 #[repr(C)]
7367 pub struct Capability {
7368 pub id: u8,
7369
7370 pub offset: u8,
7371 }
7372
7373 static_assertions::const_assert_eq!(std::mem::size_of::<Capability>(), 2);
7374 static_assertions::const_assert_eq!(std::mem::align_of::<Capability>(), 1);
7375
7376 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, id), 0);
7377
7378 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, offset), 1);
7379
7380 impl ::fidl_next::Constrained for Capability {
7381 type Constraint = ();
7382
7383 fn validate(
7384 _: ::fidl_next::Slot<'_, Self>,
7385 _: Self::Constraint,
7386 ) -> Result<(), ::fidl_next::ValidationError> {
7387 Ok(())
7388 }
7389 }
7390
7391 unsafe impl ::fidl_next::Wire for Capability {
7392 type Narrowed<'de> = Capability;
7393
7394 #[inline]
7395 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7396 ::fidl_next::munge! {
7397 let Self {
7398 id,
7399 offset,
7400
7401 } = &mut *out_;
7402 }
7403
7404 ::fidl_next::Wire::zero_padding(id);
7405
7406 ::fidl_next::Wire::zero_padding(offset);
7407 }
7408 }
7409
7410 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability
7411 where
7412 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7413 {
7414 fn decode(
7415 slot_: ::fidl_next::Slot<'_, Self>,
7416 decoder_: &mut ___D,
7417 _: (),
7418 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7419 ::fidl_next::munge! {
7420 let Self {
7421 mut id,
7422 mut offset,
7423
7424 } = slot_;
7425 }
7426
7427 let _field = id.as_mut();
7428
7429 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7430
7431 let _field = offset.as_mut();
7432
7433 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7434
7435 Ok(())
7436 }
7437 }
7438
7439 impl ::fidl_next::IntoNatural for Capability {
7440 type Natural = crate::natural::Capability;
7441 }
7442
7443 #[derive(Clone, Debug)]
7445 #[repr(C)]
7446 pub struct ExtendedCapability {
7447 pub id: ::fidl_next::wire::Uint16,
7448
7449 pub offset: ::fidl_next::wire::Uint16,
7450 }
7451
7452 static_assertions::const_assert_eq!(std::mem::size_of::<ExtendedCapability>(), 4);
7453 static_assertions::const_assert_eq!(std::mem::align_of::<ExtendedCapability>(), 2);
7454
7455 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, id), 0);
7456
7457 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, offset), 2);
7458
7459 impl ::fidl_next::Constrained for ExtendedCapability {
7460 type Constraint = ();
7461
7462 fn validate(
7463 _: ::fidl_next::Slot<'_, Self>,
7464 _: Self::Constraint,
7465 ) -> Result<(), ::fidl_next::ValidationError> {
7466 Ok(())
7467 }
7468 }
7469
7470 unsafe impl ::fidl_next::Wire for ExtendedCapability {
7471 type Narrowed<'de> = ExtendedCapability;
7472
7473 #[inline]
7474 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7475 ::fidl_next::munge! {
7476 let Self {
7477 id,
7478 offset,
7479
7480 } = &mut *out_;
7481 }
7482
7483 ::fidl_next::Wire::zero_padding(id);
7484
7485 ::fidl_next::Wire::zero_padding(offset);
7486 }
7487 }
7488
7489 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapability
7490 where
7491 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7492 {
7493 fn decode(
7494 slot_: ::fidl_next::Slot<'_, Self>,
7495 decoder_: &mut ___D,
7496 _: (),
7497 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7498 ::fidl_next::munge! {
7499 let Self {
7500 mut id,
7501 mut offset,
7502
7503 } = slot_;
7504 }
7505
7506 let _field = id.as_mut();
7507
7508 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7509
7510 let _field = offset.as_mut();
7511
7512 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7513
7514 Ok(())
7515 }
7516 }
7517
7518 impl ::fidl_next::IntoNatural for ExtendedCapability {
7519 type Natural = crate::natural::ExtendedCapability;
7520 }
7521
7522 #[derive(Debug)]
7524 #[repr(C)]
7525 pub struct PciDevice<'de> {
7526 pub base_addresses: ::fidl_next::wire::Vector<'de, crate::wire::BaseAddress>,
7527
7528 pub capabilities: ::fidl_next::wire::Vector<'de, crate::wire::Capability>,
7529
7530 pub ext_capabilities: ::fidl_next::wire::Vector<'de, crate::wire::ExtendedCapability>,
7531
7532 pub config: ::fidl_next::wire::Vector<'de, u8>,
7533
7534 pub bus_id: u8,
7535
7536 pub device_id: u8,
7537
7538 pub function_id: u8,
7539 }
7540
7541 static_assertions::const_assert_eq!(std::mem::size_of::<PciDevice<'_>>(), 72);
7542 static_assertions::const_assert_eq!(std::mem::align_of::<PciDevice<'_>>(), 8);
7543
7544 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, base_addresses), 0);
7545
7546 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, capabilities), 16);
7547
7548 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, ext_capabilities), 32);
7549
7550 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, config), 48);
7551
7552 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, bus_id), 64);
7553
7554 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, device_id), 65);
7555
7556 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, function_id), 66);
7557
7558 impl ::fidl_next::Constrained for PciDevice<'_> {
7559 type Constraint = ();
7560
7561 fn validate(
7562 _: ::fidl_next::Slot<'_, Self>,
7563 _: Self::Constraint,
7564 ) -> Result<(), ::fidl_next::ValidationError> {
7565 Ok(())
7566 }
7567 }
7568
7569 unsafe impl ::fidl_next::Wire for PciDevice<'static> {
7570 type Narrowed<'de> = PciDevice<'de>;
7571
7572 #[inline]
7573 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7574 ::fidl_next::munge! {
7575 let Self {
7576 base_addresses,
7577 capabilities,
7578 ext_capabilities,
7579 config,
7580 bus_id,
7581 device_id,
7582 function_id,
7583
7584 } = &mut *out_;
7585 }
7586
7587 ::fidl_next::Wire::zero_padding(base_addresses);
7588
7589 ::fidl_next::Wire::zero_padding(capabilities);
7590
7591 ::fidl_next::Wire::zero_padding(ext_capabilities);
7592
7593 ::fidl_next::Wire::zero_padding(config);
7594
7595 ::fidl_next::Wire::zero_padding(bus_id);
7596
7597 ::fidl_next::Wire::zero_padding(device_id);
7598
7599 ::fidl_next::Wire::zero_padding(function_id);
7600
7601 unsafe {
7602 out_.as_mut_ptr().cast::<u8>().add(67).write_bytes(0, 5);
7603 }
7604 }
7605 }
7606
7607 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PciDevice<'de>
7608 where
7609 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7610 ___D: ::fidl_next::Decoder<'de>,
7611 {
7612 fn decode(
7613 slot_: ::fidl_next::Slot<'_, Self>,
7614 decoder_: &mut ___D,
7615 _: (),
7616 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7617 if slot_.as_bytes()[67..72] != [0u8; 5] {
7618 return Err(::fidl_next::DecodeError::InvalidPadding);
7619 }
7620
7621 ::fidl_next::munge! {
7622 let Self {
7623 mut base_addresses,
7624 mut capabilities,
7625 mut ext_capabilities,
7626 mut config,
7627 mut bus_id,
7628 mut device_id,
7629 mut function_id,
7630
7631 } = slot_;
7632 }
7633
7634 let _field = base_addresses.as_mut();
7635 ::fidl_next::Constrained::validate(_field, (6, ()))?;
7636 ::fidl_next::Decode::decode(base_addresses.as_mut(), decoder_, (6, ()))?;
7637
7638 let base_addresses = unsafe { base_addresses.deref_unchecked() };
7639
7640 if base_addresses.len() > 6 {
7641 return Err(::fidl_next::DecodeError::VectorTooLong {
7642 size: base_addresses.len() as u64,
7643 limit: 6,
7644 });
7645 }
7646
7647 let _field = capabilities.as_mut();
7648 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7649 ::fidl_next::Decode::decode(capabilities.as_mut(), decoder_, (32, ()))?;
7650
7651 let capabilities = unsafe { capabilities.deref_unchecked() };
7652
7653 if capabilities.len() > 32 {
7654 return Err(::fidl_next::DecodeError::VectorTooLong {
7655 size: capabilities.len() as u64,
7656 limit: 32,
7657 });
7658 }
7659
7660 let _field = ext_capabilities.as_mut();
7661 ::fidl_next::Constrained::validate(_field, (32, ()))?;
7662 ::fidl_next::Decode::decode(ext_capabilities.as_mut(), decoder_, (32, ()))?;
7663
7664 let ext_capabilities = unsafe { ext_capabilities.deref_unchecked() };
7665
7666 if ext_capabilities.len() > 32 {
7667 return Err(::fidl_next::DecodeError::VectorTooLong {
7668 size: ext_capabilities.len() as u64,
7669 limit: 32,
7670 });
7671 }
7672
7673 let _field = config.as_mut();
7674 ::fidl_next::Constrained::validate(_field, (256, ()))?;
7675 ::fidl_next::Decode::decode(config.as_mut(), decoder_, (256, ()))?;
7676
7677 let config = unsafe { config.deref_unchecked() };
7678
7679 if config.len() > 256 {
7680 return Err(::fidl_next::DecodeError::VectorTooLong {
7681 size: config.len() as u64,
7682 limit: 256,
7683 });
7684 }
7685
7686 let _field = bus_id.as_mut();
7687
7688 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
7689
7690 let _field = device_id.as_mut();
7691
7692 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
7693
7694 let _field = function_id.as_mut();
7695
7696 ::fidl_next::Decode::decode(function_id.as_mut(), decoder_, ())?;
7697
7698 Ok(())
7699 }
7700 }
7701
7702 impl<'de> ::fidl_next::IntoNatural for PciDevice<'de> {
7703 type Natural = crate::natural::PciDevice;
7704 }
7705
7706 #[derive(Debug)]
7708 #[repr(C)]
7709 pub struct BusGetDevicesResponse<'de> {
7710 pub devices: ::fidl_next::wire::Vector<'de, crate::wire::PciDevice<'de>>,
7711 }
7712
7713 static_assertions::const_assert_eq!(std::mem::size_of::<BusGetDevicesResponse<'_>>(), 16);
7714 static_assertions::const_assert_eq!(std::mem::align_of::<BusGetDevicesResponse<'_>>(), 8);
7715
7716 static_assertions::const_assert_eq!(
7717 std::mem::offset_of!(BusGetDevicesResponse<'_>, devices),
7718 0
7719 );
7720
7721 impl ::fidl_next::Constrained for BusGetDevicesResponse<'_> {
7722 type Constraint = ();
7723
7724 fn validate(
7725 _: ::fidl_next::Slot<'_, Self>,
7726 _: Self::Constraint,
7727 ) -> Result<(), ::fidl_next::ValidationError> {
7728 Ok(())
7729 }
7730 }
7731
7732 unsafe impl ::fidl_next::Wire for BusGetDevicesResponse<'static> {
7733 type Narrowed<'de> = BusGetDevicesResponse<'de>;
7734
7735 #[inline]
7736 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7737 ::fidl_next::munge! {
7738 let Self {
7739 devices,
7740
7741 } = &mut *out_;
7742 }
7743
7744 ::fidl_next::Wire::zero_padding(devices);
7745 }
7746 }
7747
7748 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusGetDevicesResponse<'de>
7749 where
7750 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7751 ___D: ::fidl_next::Decoder<'de>,
7752 {
7753 fn decode(
7754 slot_: ::fidl_next::Slot<'_, Self>,
7755 decoder_: &mut ___D,
7756 _: (),
7757 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7758 ::fidl_next::munge! {
7759 let Self {
7760 mut devices,
7761
7762 } = slot_;
7763 }
7764
7765 let _field = devices.as_mut();
7766 ::fidl_next::Constrained::validate(_field, (64, ()))?;
7767 ::fidl_next::Decode::decode(devices.as_mut(), decoder_, (64, ()))?;
7768
7769 let devices = unsafe { devices.deref_unchecked() };
7770
7771 if devices.len() > 64 {
7772 return Err(::fidl_next::DecodeError::VectorTooLong {
7773 size: devices.len() as u64,
7774 limit: 64,
7775 });
7776 }
7777
7778 Ok(())
7779 }
7780 }
7781
7782 impl<'de> ::fidl_next::IntoNatural for BusGetDevicesResponse<'de> {
7783 type Natural = crate::natural::BusGetDevicesResponse;
7784 }
7785
7786 #[derive(Clone, Debug)]
7788 #[repr(C)]
7789 pub struct BusReadBarRequest {
7790 pub device: crate::wire::Address,
7791
7792 pub bar_id: u8,
7793
7794 pub offset: ::fidl_next::wire::Uint64,
7795
7796 pub size: ::fidl_next::wire::Uint64,
7797 }
7798
7799 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarRequest>(), 24);
7800 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarRequest>(), 8);
7801
7802 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, device), 0);
7803
7804 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, bar_id), 3);
7805
7806 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, offset), 8);
7807
7808 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarRequest, size), 16);
7809
7810 impl ::fidl_next::Constrained for BusReadBarRequest {
7811 type Constraint = ();
7812
7813 fn validate(
7814 _: ::fidl_next::Slot<'_, Self>,
7815 _: Self::Constraint,
7816 ) -> Result<(), ::fidl_next::ValidationError> {
7817 Ok(())
7818 }
7819 }
7820
7821 unsafe impl ::fidl_next::Wire for BusReadBarRequest {
7822 type Narrowed<'de> = BusReadBarRequest;
7823
7824 #[inline]
7825 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7826 ::fidl_next::munge! {
7827 let Self {
7828 device,
7829 bar_id,
7830 offset,
7831 size,
7832
7833 } = &mut *out_;
7834 }
7835
7836 ::fidl_next::Wire::zero_padding(device);
7837
7838 ::fidl_next::Wire::zero_padding(bar_id);
7839
7840 ::fidl_next::Wire::zero_padding(offset);
7841
7842 ::fidl_next::Wire::zero_padding(size);
7843
7844 unsafe {
7845 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
7846 }
7847 }
7848 }
7849
7850 unsafe impl<___D> ::fidl_next::Decode<___D> for BusReadBarRequest
7851 where
7852 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7853 {
7854 fn decode(
7855 slot_: ::fidl_next::Slot<'_, Self>,
7856 decoder_: &mut ___D,
7857 _: (),
7858 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7859 if slot_.as_bytes()[4..8] != [0u8; 4] {
7860 return Err(::fidl_next::DecodeError::InvalidPadding);
7861 }
7862
7863 ::fidl_next::munge! {
7864 let Self {
7865 mut device,
7866 mut bar_id,
7867 mut offset,
7868 mut size,
7869
7870 } = slot_;
7871 }
7872
7873 let _field = device.as_mut();
7874
7875 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
7876
7877 let _field = bar_id.as_mut();
7878
7879 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
7880
7881 let _field = offset.as_mut();
7882
7883 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7884
7885 let _field = size.as_mut();
7886
7887 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
7888
7889 Ok(())
7890 }
7891 }
7892
7893 impl ::fidl_next::IntoNatural for BusReadBarRequest {
7894 type Natural = crate::natural::BusReadBarRequest;
7895 }
7896
7897 #[derive(Debug)]
7899 #[repr(C)]
7900 pub struct BusReadBarResponse<'de> {
7901 pub buffer: ::fidl_next::wire::Vector<'de, u8>,
7902 }
7903
7904 static_assertions::const_assert_eq!(std::mem::size_of::<BusReadBarResponse<'_>>(), 16);
7905 static_assertions::const_assert_eq!(std::mem::align_of::<BusReadBarResponse<'_>>(), 8);
7906
7907 static_assertions::const_assert_eq!(std::mem::offset_of!(BusReadBarResponse<'_>, buffer), 0);
7908
7909 impl ::fidl_next::Constrained for BusReadBarResponse<'_> {
7910 type Constraint = ();
7911
7912 fn validate(
7913 _: ::fidl_next::Slot<'_, Self>,
7914 _: Self::Constraint,
7915 ) -> Result<(), ::fidl_next::ValidationError> {
7916 Ok(())
7917 }
7918 }
7919
7920 unsafe impl ::fidl_next::Wire for BusReadBarResponse<'static> {
7921 type Narrowed<'de> = BusReadBarResponse<'de>;
7922
7923 #[inline]
7924 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7925 ::fidl_next::munge! {
7926 let Self {
7927 buffer,
7928
7929 } = &mut *out_;
7930 }
7931
7932 ::fidl_next::Wire::zero_padding(buffer);
7933 }
7934 }
7935
7936 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BusReadBarResponse<'de>
7937 where
7938 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7939 ___D: ::fidl_next::Decoder<'de>,
7940 {
7941 fn decode(
7942 slot_: ::fidl_next::Slot<'_, Self>,
7943 decoder_: &mut ___D,
7944 _: (),
7945 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7946 ::fidl_next::munge! {
7947 let Self {
7948 mut buffer,
7949
7950 } = slot_;
7951 }
7952
7953 let _field = buffer.as_mut();
7954 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
7955 ::fidl_next::Decode::decode(buffer.as_mut(), decoder_, (4294967295, ()))?;
7956
7957 Ok(())
7958 }
7959 }
7960
7961 impl<'de> ::fidl_next::IntoNatural for BusReadBarResponse<'de> {
7962 type Natural = crate::natural::BusReadBarResponse;
7963 }
7964
7965 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7967 #[repr(transparent)]
7968 pub struct CapabilityId {
7969 pub(crate) value: u8,
7970 }
7971
7972 impl ::fidl_next::Constrained for CapabilityId {
7973 type Constraint = ();
7974
7975 fn validate(
7976 _: ::fidl_next::Slot<'_, Self>,
7977 _: Self::Constraint,
7978 ) -> Result<(), ::fidl_next::ValidationError> {
7979 Ok(())
7980 }
7981 }
7982
7983 unsafe impl ::fidl_next::Wire for CapabilityId {
7984 type Narrowed<'de> = Self;
7985
7986 #[inline]
7987 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
7988 }
7990 }
7991
7992 impl CapabilityId {
7993 pub const NULL: CapabilityId = CapabilityId { value: 0 };
7994
7995 pub const PCI_PWR_MGMT: CapabilityId = CapabilityId { value: 1 };
7996
7997 pub const AGP: CapabilityId = CapabilityId { value: 2 };
7998
7999 pub const VITAL_PRODUCT_DATA: CapabilityId = CapabilityId { value: 3 };
8000
8001 pub const SLOT_IDENTIFICATION: CapabilityId = CapabilityId { value: 4 };
8002
8003 pub const MSI: CapabilityId = CapabilityId { value: 5 };
8004
8005 pub const COMPACT_PCI_HOTSWAP: CapabilityId = CapabilityId { value: 6 };
8006
8007 pub const PCIX: CapabilityId = CapabilityId { value: 7 };
8008
8009 pub const HYPERTRANSPORT: CapabilityId = CapabilityId { value: 8 };
8010
8011 pub const VENDOR: CapabilityId = CapabilityId { value: 9 };
8012
8013 pub const DEBUG_PORT: CapabilityId = CapabilityId { value: 10 };
8014
8015 pub const COMPACT_PCI_CRC: CapabilityId = CapabilityId { value: 11 };
8016
8017 pub const PCI_HOT_PLUG: CapabilityId = CapabilityId { value: 12 };
8018
8019 pub const PCI_BRIDGE_SUBSYSTEM_VID: CapabilityId = CapabilityId { value: 13 };
8020
8021 pub const AGP8_X: CapabilityId = CapabilityId { value: 14 };
8022
8023 pub const SECURE_DEVICE: CapabilityId = CapabilityId { value: 15 };
8024
8025 pub const PCI_EXPRESS: CapabilityId = CapabilityId { value: 16 };
8026
8027 pub const MSIX: CapabilityId = CapabilityId { value: 17 };
8028
8029 pub const SATA_DATA_NDX_CFG: CapabilityId = CapabilityId { value: 18 };
8030
8031 pub const ADVANCED_FEATURES: CapabilityId = CapabilityId { value: 19 };
8032
8033 pub const ENHANCED_ALLOCATION: CapabilityId = CapabilityId { value: 20 };
8034
8035 pub const FLATTENING_PORTAL_BRIDGE: CapabilityId = CapabilityId { value: 21 };
8036 }
8037
8038 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityId
8039 where
8040 ___D: ?Sized,
8041 {
8042 fn decode(
8043 slot: ::fidl_next::Slot<'_, Self>,
8044 _: &mut ___D,
8045 _: (),
8046 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8047 Ok(())
8048 }
8049 }
8050
8051 impl ::core::convert::From<crate::natural::CapabilityId> for CapabilityId {
8052 fn from(natural: crate::natural::CapabilityId) -> Self {
8053 match natural {
8054 crate::natural::CapabilityId::Null => CapabilityId::NULL,
8055
8056 crate::natural::CapabilityId::PciPwrMgmt => CapabilityId::PCI_PWR_MGMT,
8057
8058 crate::natural::CapabilityId::Agp => CapabilityId::AGP,
8059
8060 crate::natural::CapabilityId::VitalProductData => CapabilityId::VITAL_PRODUCT_DATA,
8061
8062 crate::natural::CapabilityId::SlotIdentification => {
8063 CapabilityId::SLOT_IDENTIFICATION
8064 }
8065
8066 crate::natural::CapabilityId::Msi => CapabilityId::MSI,
8067
8068 crate::natural::CapabilityId::CompactPciHotswap => {
8069 CapabilityId::COMPACT_PCI_HOTSWAP
8070 }
8071
8072 crate::natural::CapabilityId::Pcix => CapabilityId::PCIX,
8073
8074 crate::natural::CapabilityId::Hypertransport => CapabilityId::HYPERTRANSPORT,
8075
8076 crate::natural::CapabilityId::Vendor => CapabilityId::VENDOR,
8077
8078 crate::natural::CapabilityId::DebugPort => CapabilityId::DEBUG_PORT,
8079
8080 crate::natural::CapabilityId::CompactPciCrc => CapabilityId::COMPACT_PCI_CRC,
8081
8082 crate::natural::CapabilityId::PciHotPlug => CapabilityId::PCI_HOT_PLUG,
8083
8084 crate::natural::CapabilityId::PciBridgeSubsystemVid => {
8085 CapabilityId::PCI_BRIDGE_SUBSYSTEM_VID
8086 }
8087
8088 crate::natural::CapabilityId::Agp8X => CapabilityId::AGP8_X,
8089
8090 crate::natural::CapabilityId::SecureDevice => CapabilityId::SECURE_DEVICE,
8091
8092 crate::natural::CapabilityId::PciExpress => CapabilityId::PCI_EXPRESS,
8093
8094 crate::natural::CapabilityId::Msix => CapabilityId::MSIX,
8095
8096 crate::natural::CapabilityId::SataDataNdxCfg => CapabilityId::SATA_DATA_NDX_CFG,
8097
8098 crate::natural::CapabilityId::AdvancedFeatures => CapabilityId::ADVANCED_FEATURES,
8099
8100 crate::natural::CapabilityId::EnhancedAllocation => {
8101 CapabilityId::ENHANCED_ALLOCATION
8102 }
8103
8104 crate::natural::CapabilityId::FlatteningPortalBridge => {
8105 CapabilityId::FLATTENING_PORTAL_BRIDGE
8106 }
8107
8108 crate::natural::CapabilityId::UnknownOrdinal_(value) => {
8109 CapabilityId { value: u8::from(value) }
8110 }
8111 }
8112 }
8113 }
8114
8115 impl ::fidl_next::IntoNatural for CapabilityId {
8116 type Natural = crate::natural::CapabilityId;
8117 }
8118
8119 #[derive(Clone, Copy, Debug)]
8121 #[repr(transparent)]
8122 pub struct Command {
8123 pub(crate) value: ::fidl_next::wire::Uint16,
8124 }
8125
8126 impl ::fidl_next::Constrained for Command {
8127 type Constraint = ();
8128
8129 fn validate(
8130 _: ::fidl_next::Slot<'_, Self>,
8131 _: Self::Constraint,
8132 ) -> Result<(), ::fidl_next::ValidationError> {
8133 Ok(())
8134 }
8135 }
8136
8137 unsafe impl ::fidl_next::Wire for Command {
8138 type Narrowed<'de> = Self;
8139
8140 #[inline]
8141 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8142 }
8144 }
8145
8146 unsafe impl<___D> ::fidl_next::Decode<___D> for Command
8147 where
8148 ___D: ?Sized,
8149 {
8150 fn decode(
8151 slot: ::fidl_next::Slot<'_, Self>,
8152 _: &mut ___D,
8153 _: (),
8154 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8155 Ok(())
8156 }
8157 }
8158
8159 impl ::core::convert::From<crate::natural::Command> for Command {
8160 fn from(natural: crate::natural::Command) -> Self {
8161 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
8162 }
8163 }
8164
8165 impl ::fidl_next::IntoNatural for Command {
8166 type Natural = crate::natural::Command;
8167 }
8168
8169 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8171 #[repr(transparent)]
8172 pub struct Config {
8173 pub(crate) value: ::fidl_next::wire::Uint16,
8174 }
8175
8176 impl ::fidl_next::Constrained for Config {
8177 type Constraint = ();
8178
8179 fn validate(
8180 _: ::fidl_next::Slot<'_, Self>,
8181 _: Self::Constraint,
8182 ) -> Result<(), ::fidl_next::ValidationError> {
8183 Ok(())
8184 }
8185 }
8186
8187 unsafe impl ::fidl_next::Wire for Config {
8188 type Narrowed<'de> = Self;
8189
8190 #[inline]
8191 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8192 }
8194 }
8195
8196 impl Config {
8197 pub const VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(0) };
8198
8199 pub const DEVICE_ID: Config = Config { value: ::fidl_next::wire::Uint16(2) };
8200
8201 pub const COMMAND: Config = Config { value: ::fidl_next::wire::Uint16(4) };
8202
8203 pub const STATUS: Config = Config { value: ::fidl_next::wire::Uint16(6) };
8204
8205 pub const REVISION_ID: Config = Config { value: ::fidl_next::wire::Uint16(8) };
8206
8207 pub const CLASS_CODE_INTR: Config = Config { value: ::fidl_next::wire::Uint16(9) };
8208
8209 pub const CLASS_CODE_SUB: Config = Config { value: ::fidl_next::wire::Uint16(10) };
8210
8211 pub const CLASS_CODE_BASE: Config = Config { value: ::fidl_next::wire::Uint16(11) };
8212
8213 pub const CACHE_LINE_SIZE: Config = Config { value: ::fidl_next::wire::Uint16(12) };
8214
8215 pub const LATENCY_TIMER: Config = Config { value: ::fidl_next::wire::Uint16(13) };
8216
8217 pub const HEADER_TYPE: Config = Config { value: ::fidl_next::wire::Uint16(14) };
8218
8219 pub const BIST: Config = Config { value: ::fidl_next::wire::Uint16(15) };
8220
8221 pub const BASE_ADDRESSES: Config = Config { value: ::fidl_next::wire::Uint16(16) };
8222
8223 pub const CARDBUS_CIS_PTR: Config = Config { value: ::fidl_next::wire::Uint16(40) };
8224
8225 pub const SUBSYSTEM_VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(44) };
8226
8227 pub const SUBSYSTEM_ID: Config = Config { value: ::fidl_next::wire::Uint16(46) };
8228
8229 pub const EXP_ROM_ADDRESS: Config = Config { value: ::fidl_next::wire::Uint16(48) };
8230
8231 pub const CAPABILITIES_PTR: Config = Config { value: ::fidl_next::wire::Uint16(52) };
8232
8233 pub const INTERRUPT_LINE: Config = Config { value: ::fidl_next::wire::Uint16(60) };
8234
8235 pub const INTERRUPT_PIN: Config = Config { value: ::fidl_next::wire::Uint16(61) };
8236
8237 pub const MIN_GRANT: Config = Config { value: ::fidl_next::wire::Uint16(62) };
8238
8239 pub const MAX_LATENCY: Config = Config { value: ::fidl_next::wire::Uint16(63) };
8240 }
8241
8242 unsafe impl<___D> ::fidl_next::Decode<___D> for Config
8243 where
8244 ___D: ?Sized,
8245 {
8246 fn decode(
8247 slot: ::fidl_next::Slot<'_, Self>,
8248 _: &mut ___D,
8249 _: (),
8250 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8251 Ok(())
8252 }
8253 }
8254
8255 impl ::core::convert::From<crate::natural::Config> for Config {
8256 fn from(natural: crate::natural::Config) -> Self {
8257 match natural {
8258 crate::natural::Config::VendorId => Config::VENDOR_ID,
8259
8260 crate::natural::Config::DeviceId => Config::DEVICE_ID,
8261
8262 crate::natural::Config::Command => Config::COMMAND,
8263
8264 crate::natural::Config::Status => Config::STATUS,
8265
8266 crate::natural::Config::RevisionId => Config::REVISION_ID,
8267
8268 crate::natural::Config::ClassCodeIntr => Config::CLASS_CODE_INTR,
8269
8270 crate::natural::Config::ClassCodeSub => Config::CLASS_CODE_SUB,
8271
8272 crate::natural::Config::ClassCodeBase => Config::CLASS_CODE_BASE,
8273
8274 crate::natural::Config::CacheLineSize => Config::CACHE_LINE_SIZE,
8275
8276 crate::natural::Config::LatencyTimer => Config::LATENCY_TIMER,
8277
8278 crate::natural::Config::HeaderType => Config::HEADER_TYPE,
8279
8280 crate::natural::Config::Bist => Config::BIST,
8281
8282 crate::natural::Config::BaseAddresses => Config::BASE_ADDRESSES,
8283
8284 crate::natural::Config::CardbusCisPtr => Config::CARDBUS_CIS_PTR,
8285
8286 crate::natural::Config::SubsystemVendorId => Config::SUBSYSTEM_VENDOR_ID,
8287
8288 crate::natural::Config::SubsystemId => Config::SUBSYSTEM_ID,
8289
8290 crate::natural::Config::ExpRomAddress => Config::EXP_ROM_ADDRESS,
8291
8292 crate::natural::Config::CapabilitiesPtr => Config::CAPABILITIES_PTR,
8293
8294 crate::natural::Config::InterruptLine => Config::INTERRUPT_LINE,
8295
8296 crate::natural::Config::InterruptPin => Config::INTERRUPT_PIN,
8297
8298 crate::natural::Config::MinGrant => Config::MIN_GRANT,
8299
8300 crate::natural::Config::MaxLatency => Config::MAX_LATENCY,
8301
8302 crate::natural::Config::UnknownOrdinal_(value) => {
8303 Config { value: ::fidl_next::wire::Uint16::from(value) }
8304 }
8305 }
8306 }
8307 }
8308
8309 impl ::fidl_next::IntoNatural for Config {
8310 type Natural = crate::natural::Config;
8311 }
8312
8313 pub type ConfigOffset = u8;
8315
8316 pub type Padding = ::fidl_next::wire::Unit;
8318
8319 #[derive(Clone, Debug)]
8321 #[repr(C)]
8322 pub struct DeviceInfo {
8323 pub vendor_id: ::fidl_next::wire::Uint16,
8324
8325 pub device_id: ::fidl_next::wire::Uint16,
8326
8327 pub base_class: u8,
8328
8329 pub sub_class: u8,
8330
8331 pub program_interface: u8,
8332
8333 pub revision_id: u8,
8334
8335 pub bus_id: u8,
8336
8337 pub dev_id: u8,
8338
8339 pub func_id: u8,
8340
8341 pub padding: crate::wire::Padding,
8342 }
8343
8344 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceInfo>(), 12);
8345 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceInfo>(), 2);
8346
8347 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, vendor_id), 0);
8348
8349 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, device_id), 2);
8350
8351 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, base_class), 4);
8352
8353 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, sub_class), 5);
8354
8355 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, program_interface), 6);
8356
8357 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, revision_id), 7);
8358
8359 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, bus_id), 8);
8360
8361 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, dev_id), 9);
8362
8363 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, func_id), 10);
8364
8365 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, padding), 11);
8366
8367 impl ::fidl_next::Constrained for DeviceInfo {
8368 type Constraint = ();
8369
8370 fn validate(
8371 _: ::fidl_next::Slot<'_, Self>,
8372 _: Self::Constraint,
8373 ) -> Result<(), ::fidl_next::ValidationError> {
8374 Ok(())
8375 }
8376 }
8377
8378 unsafe impl ::fidl_next::Wire for DeviceInfo {
8379 type Narrowed<'de> = DeviceInfo;
8380
8381 #[inline]
8382 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8383 ::fidl_next::munge! {
8384 let Self {
8385 vendor_id,
8386 device_id,
8387 base_class,
8388 sub_class,
8389 program_interface,
8390 revision_id,
8391 bus_id,
8392 dev_id,
8393 func_id,
8394 padding,
8395
8396 } = &mut *out_;
8397 }
8398
8399 ::fidl_next::Wire::zero_padding(vendor_id);
8400
8401 ::fidl_next::Wire::zero_padding(device_id);
8402
8403 ::fidl_next::Wire::zero_padding(base_class);
8404
8405 ::fidl_next::Wire::zero_padding(sub_class);
8406
8407 ::fidl_next::Wire::zero_padding(program_interface);
8408
8409 ::fidl_next::Wire::zero_padding(revision_id);
8410
8411 ::fidl_next::Wire::zero_padding(bus_id);
8412
8413 ::fidl_next::Wire::zero_padding(dev_id);
8414
8415 ::fidl_next::Wire::zero_padding(func_id);
8416
8417 ::fidl_next::Wire::zero_padding(padding);
8418 }
8419 }
8420
8421 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceInfo
8422 where
8423 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8424 {
8425 fn decode(
8426 slot_: ::fidl_next::Slot<'_, Self>,
8427 decoder_: &mut ___D,
8428 _: (),
8429 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8430 ::fidl_next::munge! {
8431 let Self {
8432 mut vendor_id,
8433 mut device_id,
8434 mut base_class,
8435 mut sub_class,
8436 mut program_interface,
8437 mut revision_id,
8438 mut bus_id,
8439 mut dev_id,
8440 mut func_id,
8441 mut padding,
8442
8443 } = slot_;
8444 }
8445
8446 let _field = vendor_id.as_mut();
8447
8448 ::fidl_next::Decode::decode(vendor_id.as_mut(), decoder_, ())?;
8449
8450 let _field = device_id.as_mut();
8451
8452 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
8453
8454 let _field = base_class.as_mut();
8455
8456 ::fidl_next::Decode::decode(base_class.as_mut(), decoder_, ())?;
8457
8458 let _field = sub_class.as_mut();
8459
8460 ::fidl_next::Decode::decode(sub_class.as_mut(), decoder_, ())?;
8461
8462 let _field = program_interface.as_mut();
8463
8464 ::fidl_next::Decode::decode(program_interface.as_mut(), decoder_, ())?;
8465
8466 let _field = revision_id.as_mut();
8467
8468 ::fidl_next::Decode::decode(revision_id.as_mut(), decoder_, ())?;
8469
8470 let _field = bus_id.as_mut();
8471
8472 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
8473
8474 let _field = dev_id.as_mut();
8475
8476 ::fidl_next::Decode::decode(dev_id.as_mut(), decoder_, ())?;
8477
8478 let _field = func_id.as_mut();
8479
8480 ::fidl_next::Decode::decode(func_id.as_mut(), decoder_, ())?;
8481
8482 let _field = padding.as_mut();
8483
8484 ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
8485
8486 Ok(())
8487 }
8488 }
8489
8490 impl ::fidl_next::IntoNatural for DeviceInfo {
8491 type Natural = crate::natural::DeviceInfo;
8492 }
8493
8494 #[derive(Clone, Debug)]
8496 #[repr(C)]
8497 pub struct DeviceGetDeviceInfoResponse {
8498 pub info: crate::wire::DeviceInfo,
8499 }
8500
8501 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetDeviceInfoResponse>(), 12);
8502 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetDeviceInfoResponse>(), 2);
8503
8504 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetDeviceInfoResponse, info), 0);
8505
8506 impl ::fidl_next::Constrained for DeviceGetDeviceInfoResponse {
8507 type Constraint = ();
8508
8509 fn validate(
8510 _: ::fidl_next::Slot<'_, Self>,
8511 _: Self::Constraint,
8512 ) -> Result<(), ::fidl_next::ValidationError> {
8513 Ok(())
8514 }
8515 }
8516
8517 unsafe impl ::fidl_next::Wire for DeviceGetDeviceInfoResponse {
8518 type Narrowed<'de> = DeviceGetDeviceInfoResponse;
8519
8520 #[inline]
8521 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8522 ::fidl_next::munge! {
8523 let Self {
8524 info,
8525
8526 } = &mut *out_;
8527 }
8528
8529 ::fidl_next::Wire::zero_padding(info);
8530 }
8531 }
8532
8533 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetDeviceInfoResponse
8534 where
8535 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8536 {
8537 fn decode(
8538 slot_: ::fidl_next::Slot<'_, Self>,
8539 decoder_: &mut ___D,
8540 _: (),
8541 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8542 ::fidl_next::munge! {
8543 let Self {
8544 mut info,
8545
8546 } = slot_;
8547 }
8548
8549 let _field = info.as_mut();
8550
8551 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
8552
8553 Ok(())
8554 }
8555 }
8556
8557 impl ::fidl_next::IntoNatural for DeviceGetDeviceInfoResponse {
8558 type Natural = crate::natural::DeviceGetDeviceInfoResponse;
8559 }
8560
8561 #[derive(Clone, Debug)]
8563 #[repr(C)]
8564 pub struct DeviceGetBarRequest {
8565 pub bar_id: ::fidl_next::wire::Uint32,
8566 }
8567
8568 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBarRequest>(), 4);
8569 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBarRequest>(), 4);
8570
8571 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBarRequest, bar_id), 0);
8572
8573 impl ::fidl_next::Constrained for DeviceGetBarRequest {
8574 type Constraint = ();
8575
8576 fn validate(
8577 _: ::fidl_next::Slot<'_, Self>,
8578 _: Self::Constraint,
8579 ) -> Result<(), ::fidl_next::ValidationError> {
8580 Ok(())
8581 }
8582 }
8583
8584 unsafe impl ::fidl_next::Wire for DeviceGetBarRequest {
8585 type Narrowed<'de> = DeviceGetBarRequest;
8586
8587 #[inline]
8588 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8589 ::fidl_next::munge! {
8590 let Self {
8591 bar_id,
8592
8593 } = &mut *out_;
8594 }
8595
8596 ::fidl_next::Wire::zero_padding(bar_id);
8597 }
8598 }
8599
8600 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBarRequest
8601 where
8602 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8603 {
8604 fn decode(
8605 slot_: ::fidl_next::Slot<'_, Self>,
8606 decoder_: &mut ___D,
8607 _: (),
8608 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8609 ::fidl_next::munge! {
8610 let Self {
8611 mut bar_id,
8612
8613 } = slot_;
8614 }
8615
8616 let _field = bar_id.as_mut();
8617
8618 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
8619
8620 Ok(())
8621 }
8622 }
8623
8624 impl ::fidl_next::IntoNatural for DeviceGetBarRequest {
8625 type Natural = crate::natural::DeviceGetBarRequest;
8626 }
8627
8628 #[derive(Clone, Debug)]
8630 #[repr(C)]
8631 pub struct DeviceSetBusMasteringRequest {
8632 pub enabled: bool,
8633 }
8634
8635 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetBusMasteringRequest>(), 1);
8636 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetBusMasteringRequest>(), 1);
8637
8638 static_assertions::const_assert_eq!(
8639 std::mem::offset_of!(DeviceSetBusMasteringRequest, enabled),
8640 0
8641 );
8642
8643 impl ::fidl_next::Constrained for DeviceSetBusMasteringRequest {
8644 type Constraint = ();
8645
8646 fn validate(
8647 _: ::fidl_next::Slot<'_, Self>,
8648 _: Self::Constraint,
8649 ) -> Result<(), ::fidl_next::ValidationError> {
8650 Ok(())
8651 }
8652 }
8653
8654 unsafe impl ::fidl_next::Wire for DeviceSetBusMasteringRequest {
8655 type Narrowed<'de> = DeviceSetBusMasteringRequest;
8656
8657 #[inline]
8658 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8659 ::fidl_next::munge! {
8660 let Self {
8661 enabled,
8662
8663 } = &mut *out_;
8664 }
8665
8666 ::fidl_next::Wire::zero_padding(enabled);
8667 }
8668 }
8669
8670 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetBusMasteringRequest
8671 where
8672 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8673 {
8674 fn decode(
8675 slot_: ::fidl_next::Slot<'_, Self>,
8676 decoder_: &mut ___D,
8677 _: (),
8678 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8679 ::fidl_next::munge! {
8680 let Self {
8681 mut enabled,
8682
8683 } = slot_;
8684 }
8685
8686 let _field = enabled.as_mut();
8687
8688 ::fidl_next::Decode::decode(enabled.as_mut(), decoder_, ())?;
8689
8690 Ok(())
8691 }
8692 }
8693
8694 impl ::fidl_next::IntoNatural for DeviceSetBusMasteringRequest {
8695 type Natural = crate::natural::DeviceSetBusMasteringRequest;
8696 }
8697
8698 pub type DeviceSetBusMasteringResponse = ::fidl_next::wire::Unit;
8700
8701 pub type DeviceResetDeviceResponse = ::fidl_next::wire::Unit;
8703
8704 pub type DeviceAckInterruptResponse = ::fidl_next::wire::Unit;
8706
8707 #[derive(Clone, Debug)]
8709 #[repr(C)]
8710 pub struct DeviceMapInterruptRequest {
8711 pub which_irq: ::fidl_next::wire::Uint32,
8712 }
8713
8714 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceMapInterruptRequest>(), 4);
8715 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceMapInterruptRequest>(), 4);
8716
8717 static_assertions::const_assert_eq!(
8718 std::mem::offset_of!(DeviceMapInterruptRequest, which_irq),
8719 0
8720 );
8721
8722 impl ::fidl_next::Constrained for DeviceMapInterruptRequest {
8723 type Constraint = ();
8724
8725 fn validate(
8726 _: ::fidl_next::Slot<'_, Self>,
8727 _: Self::Constraint,
8728 ) -> Result<(), ::fidl_next::ValidationError> {
8729 Ok(())
8730 }
8731 }
8732
8733 unsafe impl ::fidl_next::Wire for DeviceMapInterruptRequest {
8734 type Narrowed<'de> = DeviceMapInterruptRequest;
8735
8736 #[inline]
8737 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8738 ::fidl_next::munge! {
8739 let Self {
8740 which_irq,
8741
8742 } = &mut *out_;
8743 }
8744
8745 ::fidl_next::Wire::zero_padding(which_irq);
8746 }
8747 }
8748
8749 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceMapInterruptRequest
8750 where
8751 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8752 {
8753 fn decode(
8754 slot_: ::fidl_next::Slot<'_, Self>,
8755 decoder_: &mut ___D,
8756 _: (),
8757 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8758 ::fidl_next::munge! {
8759 let Self {
8760 mut which_irq,
8761
8762 } = slot_;
8763 }
8764
8765 let _field = which_irq.as_mut();
8766
8767 ::fidl_next::Decode::decode(which_irq.as_mut(), decoder_, ())?;
8768
8769 Ok(())
8770 }
8771 }
8772
8773 impl ::fidl_next::IntoNatural for DeviceMapInterruptRequest {
8774 type Natural = crate::natural::DeviceMapInterruptRequest;
8775 }
8776
8777 #[derive(Clone, Debug)]
8779 #[repr(C)]
8780 pub struct InterruptModes {
8781 pub has_legacy: bool,
8782
8783 pub msi_count: u8,
8784
8785 pub msix_count: ::fidl_next::wire::Uint16,
8786 }
8787
8788 static_assertions::const_assert_eq!(std::mem::size_of::<InterruptModes>(), 4);
8789 static_assertions::const_assert_eq!(std::mem::align_of::<InterruptModes>(), 2);
8790
8791 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, has_legacy), 0);
8792
8793 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msi_count), 1);
8794
8795 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msix_count), 2);
8796
8797 impl ::fidl_next::Constrained for InterruptModes {
8798 type Constraint = ();
8799
8800 fn validate(
8801 _: ::fidl_next::Slot<'_, Self>,
8802 _: Self::Constraint,
8803 ) -> Result<(), ::fidl_next::ValidationError> {
8804 Ok(())
8805 }
8806 }
8807
8808 unsafe impl ::fidl_next::Wire for InterruptModes {
8809 type Narrowed<'de> = InterruptModes;
8810
8811 #[inline]
8812 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8813 ::fidl_next::munge! {
8814 let Self {
8815 has_legacy,
8816 msi_count,
8817 msix_count,
8818
8819 } = &mut *out_;
8820 }
8821
8822 ::fidl_next::Wire::zero_padding(has_legacy);
8823
8824 ::fidl_next::Wire::zero_padding(msi_count);
8825
8826 ::fidl_next::Wire::zero_padding(msix_count);
8827 }
8828 }
8829
8830 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptModes
8831 where
8832 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8833 {
8834 fn decode(
8835 slot_: ::fidl_next::Slot<'_, Self>,
8836 decoder_: &mut ___D,
8837 _: (),
8838 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8839 ::fidl_next::munge! {
8840 let Self {
8841 mut has_legacy,
8842 mut msi_count,
8843 mut msix_count,
8844
8845 } = slot_;
8846 }
8847
8848 let _field = has_legacy.as_mut();
8849
8850 ::fidl_next::Decode::decode(has_legacy.as_mut(), decoder_, ())?;
8851
8852 let _field = msi_count.as_mut();
8853
8854 ::fidl_next::Decode::decode(msi_count.as_mut(), decoder_, ())?;
8855
8856 let _field = msix_count.as_mut();
8857
8858 ::fidl_next::Decode::decode(msix_count.as_mut(), decoder_, ())?;
8859
8860 Ok(())
8861 }
8862 }
8863
8864 impl ::fidl_next::IntoNatural for InterruptModes {
8865 type Natural = crate::natural::InterruptModes;
8866 }
8867
8868 #[derive(Clone, Debug)]
8870 #[repr(C)]
8871 pub struct DeviceGetInterruptModesResponse {
8872 pub modes: crate::wire::InterruptModes,
8873 }
8874
8875 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetInterruptModesResponse>(), 4);
8876 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetInterruptModesResponse>(), 2);
8877
8878 static_assertions::const_assert_eq!(
8879 std::mem::offset_of!(DeviceGetInterruptModesResponse, modes),
8880 0
8881 );
8882
8883 impl ::fidl_next::Constrained for DeviceGetInterruptModesResponse {
8884 type Constraint = ();
8885
8886 fn validate(
8887 _: ::fidl_next::Slot<'_, Self>,
8888 _: Self::Constraint,
8889 ) -> Result<(), ::fidl_next::ValidationError> {
8890 Ok(())
8891 }
8892 }
8893
8894 unsafe impl ::fidl_next::Wire for DeviceGetInterruptModesResponse {
8895 type Narrowed<'de> = DeviceGetInterruptModesResponse;
8896
8897 #[inline]
8898 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8899 ::fidl_next::munge! {
8900 let Self {
8901 modes,
8902
8903 } = &mut *out_;
8904 }
8905
8906 ::fidl_next::Wire::zero_padding(modes);
8907 }
8908 }
8909
8910 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetInterruptModesResponse
8911 where
8912 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8913 {
8914 fn decode(
8915 slot_: ::fidl_next::Slot<'_, Self>,
8916 decoder_: &mut ___D,
8917 _: (),
8918 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8919 ::fidl_next::munge! {
8920 let Self {
8921 mut modes,
8922
8923 } = slot_;
8924 }
8925
8926 let _field = modes.as_mut();
8927
8928 ::fidl_next::Decode::decode(modes.as_mut(), decoder_, ())?;
8929
8930 Ok(())
8931 }
8932 }
8933
8934 impl ::fidl_next::IntoNatural for DeviceGetInterruptModesResponse {
8935 type Natural = crate::natural::DeviceGetInterruptModesResponse;
8936 }
8937
8938 pub type DeviceSetInterruptModeResponse = ::fidl_next::wire::Unit;
8940
8941 pub type ExtendedConfigOffset = ::fidl_next::wire::Uint16;
8943
8944 #[derive(Clone, Debug)]
8946 #[repr(C)]
8947 pub struct DeviceReadConfig8Request {
8948 pub offset: ::fidl_next::wire::Uint16,
8949 }
8950
8951 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Request>(), 2);
8952 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Request>(), 2);
8953
8954 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Request, offset), 0);
8955
8956 impl ::fidl_next::Constrained for DeviceReadConfig8Request {
8957 type Constraint = ();
8958
8959 fn validate(
8960 _: ::fidl_next::Slot<'_, Self>,
8961 _: Self::Constraint,
8962 ) -> Result<(), ::fidl_next::ValidationError> {
8963 Ok(())
8964 }
8965 }
8966
8967 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Request {
8968 type Narrowed<'de> = DeviceReadConfig8Request;
8969
8970 #[inline]
8971 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8972 ::fidl_next::munge! {
8973 let Self {
8974 offset,
8975
8976 } = &mut *out_;
8977 }
8978
8979 ::fidl_next::Wire::zero_padding(offset);
8980 }
8981 }
8982
8983 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Request
8984 where
8985 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8986 {
8987 fn decode(
8988 slot_: ::fidl_next::Slot<'_, Self>,
8989 decoder_: &mut ___D,
8990 _: (),
8991 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8992 ::fidl_next::munge! {
8993 let Self {
8994 mut offset,
8995
8996 } = slot_;
8997 }
8998
8999 let _field = offset.as_mut();
9000
9001 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9002
9003 Ok(())
9004 }
9005 }
9006
9007 impl ::fidl_next::IntoNatural for DeviceReadConfig8Request {
9008 type Natural = crate::natural::DeviceReadConfig8Request;
9009 }
9010
9011 #[derive(Clone, Debug)]
9013 #[repr(C)]
9014 pub struct DeviceReadConfig8Response {
9015 pub value: u8,
9016 }
9017
9018 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Response>(), 1);
9019 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Response>(), 1);
9020
9021 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Response, value), 0);
9022
9023 impl ::fidl_next::Constrained for DeviceReadConfig8Response {
9024 type Constraint = ();
9025
9026 fn validate(
9027 _: ::fidl_next::Slot<'_, Self>,
9028 _: Self::Constraint,
9029 ) -> Result<(), ::fidl_next::ValidationError> {
9030 Ok(())
9031 }
9032 }
9033
9034 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Response {
9035 type Narrowed<'de> = DeviceReadConfig8Response;
9036
9037 #[inline]
9038 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9039 ::fidl_next::munge! {
9040 let Self {
9041 value,
9042
9043 } = &mut *out_;
9044 }
9045
9046 ::fidl_next::Wire::zero_padding(value);
9047 }
9048 }
9049
9050 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Response
9051 where
9052 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9053 {
9054 fn decode(
9055 slot_: ::fidl_next::Slot<'_, Self>,
9056 decoder_: &mut ___D,
9057 _: (),
9058 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9059 ::fidl_next::munge! {
9060 let Self {
9061 mut value,
9062
9063 } = slot_;
9064 }
9065
9066 let _field = value.as_mut();
9067
9068 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9069
9070 Ok(())
9071 }
9072 }
9073
9074 impl ::fidl_next::IntoNatural for DeviceReadConfig8Response {
9075 type Natural = crate::natural::DeviceReadConfig8Response;
9076 }
9077
9078 #[derive(Clone, Debug)]
9080 #[repr(C)]
9081 pub struct DeviceReadConfig16Request {
9082 pub offset: ::fidl_next::wire::Uint16,
9083 }
9084
9085 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Request>(), 2);
9086 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Request>(), 2);
9087
9088 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Request, offset), 0);
9089
9090 impl ::fidl_next::Constrained for DeviceReadConfig16Request {
9091 type Constraint = ();
9092
9093 fn validate(
9094 _: ::fidl_next::Slot<'_, Self>,
9095 _: Self::Constraint,
9096 ) -> Result<(), ::fidl_next::ValidationError> {
9097 Ok(())
9098 }
9099 }
9100
9101 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Request {
9102 type Narrowed<'de> = DeviceReadConfig16Request;
9103
9104 #[inline]
9105 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9106 ::fidl_next::munge! {
9107 let Self {
9108 offset,
9109
9110 } = &mut *out_;
9111 }
9112
9113 ::fidl_next::Wire::zero_padding(offset);
9114 }
9115 }
9116
9117 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Request
9118 where
9119 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9120 {
9121 fn decode(
9122 slot_: ::fidl_next::Slot<'_, Self>,
9123 decoder_: &mut ___D,
9124 _: (),
9125 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9126 ::fidl_next::munge! {
9127 let Self {
9128 mut offset,
9129
9130 } = slot_;
9131 }
9132
9133 let _field = offset.as_mut();
9134
9135 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9136
9137 Ok(())
9138 }
9139 }
9140
9141 impl ::fidl_next::IntoNatural for DeviceReadConfig16Request {
9142 type Natural = crate::natural::DeviceReadConfig16Request;
9143 }
9144
9145 #[derive(Clone, Debug)]
9147 #[repr(C)]
9148 pub struct DeviceReadConfig16Response {
9149 pub value: ::fidl_next::wire::Uint16,
9150 }
9151
9152 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Response>(), 2);
9153 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Response>(), 2);
9154
9155 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Response, value), 0);
9156
9157 impl ::fidl_next::Constrained for DeviceReadConfig16Response {
9158 type Constraint = ();
9159
9160 fn validate(
9161 _: ::fidl_next::Slot<'_, Self>,
9162 _: Self::Constraint,
9163 ) -> Result<(), ::fidl_next::ValidationError> {
9164 Ok(())
9165 }
9166 }
9167
9168 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Response {
9169 type Narrowed<'de> = DeviceReadConfig16Response;
9170
9171 #[inline]
9172 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9173 ::fidl_next::munge! {
9174 let Self {
9175 value,
9176
9177 } = &mut *out_;
9178 }
9179
9180 ::fidl_next::Wire::zero_padding(value);
9181 }
9182 }
9183
9184 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Response
9185 where
9186 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9187 {
9188 fn decode(
9189 slot_: ::fidl_next::Slot<'_, Self>,
9190 decoder_: &mut ___D,
9191 _: (),
9192 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9193 ::fidl_next::munge! {
9194 let Self {
9195 mut value,
9196
9197 } = slot_;
9198 }
9199
9200 let _field = value.as_mut();
9201
9202 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9203
9204 Ok(())
9205 }
9206 }
9207
9208 impl ::fidl_next::IntoNatural for DeviceReadConfig16Response {
9209 type Natural = crate::natural::DeviceReadConfig16Response;
9210 }
9211
9212 #[derive(Clone, Debug)]
9214 #[repr(C)]
9215 pub struct DeviceReadConfig32Request {
9216 pub offset: ::fidl_next::wire::Uint16,
9217 }
9218
9219 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Request>(), 2);
9220 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Request>(), 2);
9221
9222 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Request, offset), 0);
9223
9224 impl ::fidl_next::Constrained for DeviceReadConfig32Request {
9225 type Constraint = ();
9226
9227 fn validate(
9228 _: ::fidl_next::Slot<'_, Self>,
9229 _: Self::Constraint,
9230 ) -> Result<(), ::fidl_next::ValidationError> {
9231 Ok(())
9232 }
9233 }
9234
9235 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Request {
9236 type Narrowed<'de> = DeviceReadConfig32Request;
9237
9238 #[inline]
9239 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9240 ::fidl_next::munge! {
9241 let Self {
9242 offset,
9243
9244 } = &mut *out_;
9245 }
9246
9247 ::fidl_next::Wire::zero_padding(offset);
9248 }
9249 }
9250
9251 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Request
9252 where
9253 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9254 {
9255 fn decode(
9256 slot_: ::fidl_next::Slot<'_, Self>,
9257 decoder_: &mut ___D,
9258 _: (),
9259 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9260 ::fidl_next::munge! {
9261 let Self {
9262 mut offset,
9263
9264 } = slot_;
9265 }
9266
9267 let _field = offset.as_mut();
9268
9269 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9270
9271 Ok(())
9272 }
9273 }
9274
9275 impl ::fidl_next::IntoNatural for DeviceReadConfig32Request {
9276 type Natural = crate::natural::DeviceReadConfig32Request;
9277 }
9278
9279 #[derive(Clone, Debug)]
9281 #[repr(C)]
9282 pub struct DeviceReadConfig32Response {
9283 pub value: ::fidl_next::wire::Uint32,
9284 }
9285
9286 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Response>(), 4);
9287 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Response>(), 4);
9288
9289 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Response, value), 0);
9290
9291 impl ::fidl_next::Constrained for DeviceReadConfig32Response {
9292 type Constraint = ();
9293
9294 fn validate(
9295 _: ::fidl_next::Slot<'_, Self>,
9296 _: Self::Constraint,
9297 ) -> Result<(), ::fidl_next::ValidationError> {
9298 Ok(())
9299 }
9300 }
9301
9302 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Response {
9303 type Narrowed<'de> = DeviceReadConfig32Response;
9304
9305 #[inline]
9306 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9307 ::fidl_next::munge! {
9308 let Self {
9309 value,
9310
9311 } = &mut *out_;
9312 }
9313
9314 ::fidl_next::Wire::zero_padding(value);
9315 }
9316 }
9317
9318 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Response
9319 where
9320 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9321 {
9322 fn decode(
9323 slot_: ::fidl_next::Slot<'_, Self>,
9324 decoder_: &mut ___D,
9325 _: (),
9326 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9327 ::fidl_next::munge! {
9328 let Self {
9329 mut value,
9330
9331 } = slot_;
9332 }
9333
9334 let _field = value.as_mut();
9335
9336 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9337
9338 Ok(())
9339 }
9340 }
9341
9342 impl ::fidl_next::IntoNatural for DeviceReadConfig32Response {
9343 type Natural = crate::natural::DeviceReadConfig32Response;
9344 }
9345
9346 #[derive(Clone, Debug)]
9348 #[repr(C)]
9349 pub struct DeviceWriteConfig8Request {
9350 pub offset: ::fidl_next::wire::Uint16,
9351
9352 pub value: u8,
9353 }
9354
9355 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig8Request>(), 4);
9356 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig8Request>(), 2);
9357
9358 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, offset), 0);
9359
9360 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, value), 2);
9361
9362 impl ::fidl_next::Constrained for DeviceWriteConfig8Request {
9363 type Constraint = ();
9364
9365 fn validate(
9366 _: ::fidl_next::Slot<'_, Self>,
9367 _: Self::Constraint,
9368 ) -> Result<(), ::fidl_next::ValidationError> {
9369 Ok(())
9370 }
9371 }
9372
9373 unsafe impl ::fidl_next::Wire for DeviceWriteConfig8Request {
9374 type Narrowed<'de> = DeviceWriteConfig8Request;
9375
9376 #[inline]
9377 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9378 ::fidl_next::munge! {
9379 let Self {
9380 offset,
9381 value,
9382
9383 } = &mut *out_;
9384 }
9385
9386 ::fidl_next::Wire::zero_padding(offset);
9387
9388 ::fidl_next::Wire::zero_padding(value);
9389
9390 unsafe {
9391 out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 1);
9392 }
9393 }
9394 }
9395
9396 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig8Request
9397 where
9398 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9399 {
9400 fn decode(
9401 slot_: ::fidl_next::Slot<'_, Self>,
9402 decoder_: &mut ___D,
9403 _: (),
9404 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9405 if slot_.as_bytes()[3..4] != [0u8; 1] {
9406 return Err(::fidl_next::DecodeError::InvalidPadding);
9407 }
9408
9409 ::fidl_next::munge! {
9410 let Self {
9411 mut offset,
9412 mut value,
9413
9414 } = slot_;
9415 }
9416
9417 let _field = offset.as_mut();
9418
9419 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9420
9421 let _field = value.as_mut();
9422
9423 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9424
9425 Ok(())
9426 }
9427 }
9428
9429 impl ::fidl_next::IntoNatural for DeviceWriteConfig8Request {
9430 type Natural = crate::natural::DeviceWriteConfig8Request;
9431 }
9432
9433 pub type DeviceWriteConfig8Response = ::fidl_next::wire::Unit;
9435
9436 #[derive(Clone, Debug)]
9438 #[repr(C)]
9439 pub struct DeviceWriteConfig16Request {
9440 pub offset: ::fidl_next::wire::Uint16,
9441
9442 pub value: ::fidl_next::wire::Uint16,
9443 }
9444
9445 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig16Request>(), 4);
9446 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig16Request>(), 2);
9447
9448 static_assertions::const_assert_eq!(
9449 std::mem::offset_of!(DeviceWriteConfig16Request, offset),
9450 0
9451 );
9452
9453 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig16Request, value), 2);
9454
9455 impl ::fidl_next::Constrained for DeviceWriteConfig16Request {
9456 type Constraint = ();
9457
9458 fn validate(
9459 _: ::fidl_next::Slot<'_, Self>,
9460 _: Self::Constraint,
9461 ) -> Result<(), ::fidl_next::ValidationError> {
9462 Ok(())
9463 }
9464 }
9465
9466 unsafe impl ::fidl_next::Wire for DeviceWriteConfig16Request {
9467 type Narrowed<'de> = DeviceWriteConfig16Request;
9468
9469 #[inline]
9470 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9471 ::fidl_next::munge! {
9472 let Self {
9473 offset,
9474 value,
9475
9476 } = &mut *out_;
9477 }
9478
9479 ::fidl_next::Wire::zero_padding(offset);
9480
9481 ::fidl_next::Wire::zero_padding(value);
9482 }
9483 }
9484
9485 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig16Request
9486 where
9487 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9488 {
9489 fn decode(
9490 slot_: ::fidl_next::Slot<'_, Self>,
9491 decoder_: &mut ___D,
9492 _: (),
9493 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9494 ::fidl_next::munge! {
9495 let Self {
9496 mut offset,
9497 mut value,
9498
9499 } = slot_;
9500 }
9501
9502 let _field = offset.as_mut();
9503
9504 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9505
9506 let _field = value.as_mut();
9507
9508 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9509
9510 Ok(())
9511 }
9512 }
9513
9514 impl ::fidl_next::IntoNatural for DeviceWriteConfig16Request {
9515 type Natural = crate::natural::DeviceWriteConfig16Request;
9516 }
9517
9518 pub type DeviceWriteConfig16Response = ::fidl_next::wire::Unit;
9520
9521 #[derive(Clone, Debug)]
9523 #[repr(C)]
9524 pub struct DeviceWriteConfig32Request {
9525 pub offset: ::fidl_next::wire::Uint16,
9526
9527 pub value: ::fidl_next::wire::Uint32,
9528 }
9529
9530 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig32Request>(), 8);
9531 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig32Request>(), 4);
9532
9533 static_assertions::const_assert_eq!(
9534 std::mem::offset_of!(DeviceWriteConfig32Request, offset),
9535 0
9536 );
9537
9538 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig32Request, value), 4);
9539
9540 impl ::fidl_next::Constrained for DeviceWriteConfig32Request {
9541 type Constraint = ();
9542
9543 fn validate(
9544 _: ::fidl_next::Slot<'_, Self>,
9545 _: Self::Constraint,
9546 ) -> Result<(), ::fidl_next::ValidationError> {
9547 Ok(())
9548 }
9549 }
9550
9551 unsafe impl ::fidl_next::Wire for DeviceWriteConfig32Request {
9552 type Narrowed<'de> = DeviceWriteConfig32Request;
9553
9554 #[inline]
9555 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9556 ::fidl_next::munge! {
9557 let Self {
9558 offset,
9559 value,
9560
9561 } = &mut *out_;
9562 }
9563
9564 ::fidl_next::Wire::zero_padding(offset);
9565
9566 ::fidl_next::Wire::zero_padding(value);
9567
9568 unsafe {
9569 out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 2);
9570 }
9571 }
9572 }
9573
9574 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig32Request
9575 where
9576 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9577 {
9578 fn decode(
9579 slot_: ::fidl_next::Slot<'_, Self>,
9580 decoder_: &mut ___D,
9581 _: (),
9582 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9583 if slot_.as_bytes()[2..4] != [0u8; 2] {
9584 return Err(::fidl_next::DecodeError::InvalidPadding);
9585 }
9586
9587 ::fidl_next::munge! {
9588 let Self {
9589 mut offset,
9590 mut value,
9591
9592 } = slot_;
9593 }
9594
9595 let _field = offset.as_mut();
9596
9597 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9598
9599 let _field = value.as_mut();
9600
9601 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9602
9603 Ok(())
9604 }
9605 }
9606
9607 impl ::fidl_next::IntoNatural for DeviceWriteConfig32Request {
9608 type Natural = crate::natural::DeviceWriteConfig32Request;
9609 }
9610
9611 pub type DeviceWriteConfig32Response = ::fidl_next::wire::Unit;
9613
9614 #[derive(Clone, Debug)]
9616 #[repr(C)]
9617 pub struct DeviceGetCapabilitiesRequest {
9618 pub id: crate::wire::CapabilityId,
9619 }
9620
9621 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetCapabilitiesRequest>(), 1);
9622 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetCapabilitiesRequest>(), 1);
9623
9624 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetCapabilitiesRequest, id), 0);
9625
9626 impl ::fidl_next::Constrained for DeviceGetCapabilitiesRequest {
9627 type Constraint = ();
9628
9629 fn validate(
9630 _: ::fidl_next::Slot<'_, Self>,
9631 _: Self::Constraint,
9632 ) -> Result<(), ::fidl_next::ValidationError> {
9633 Ok(())
9634 }
9635 }
9636
9637 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesRequest {
9638 type Narrowed<'de> = DeviceGetCapabilitiesRequest;
9639
9640 #[inline]
9641 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9642 ::fidl_next::munge! {
9643 let Self {
9644 id,
9645
9646 } = &mut *out_;
9647 }
9648
9649 ::fidl_next::Wire::zero_padding(id);
9650 }
9651 }
9652
9653 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesRequest
9654 where
9655 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9656 {
9657 fn decode(
9658 slot_: ::fidl_next::Slot<'_, Self>,
9659 decoder_: &mut ___D,
9660 _: (),
9661 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9662 ::fidl_next::munge! {
9663 let Self {
9664 mut id,
9665
9666 } = slot_;
9667 }
9668
9669 let _field = id.as_mut();
9670
9671 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9672
9673 Ok(())
9674 }
9675 }
9676
9677 impl ::fidl_next::IntoNatural for DeviceGetCapabilitiesRequest {
9678 type Natural = crate::natural::DeviceGetCapabilitiesRequest;
9679 }
9680
9681 #[derive(Debug)]
9683 #[repr(C)]
9684 pub struct DeviceGetCapabilitiesResponse<'de> {
9685 pub offsets: ::fidl_next::wire::Vector<'de, u8>,
9686 }
9687
9688 static_assertions::const_assert_eq!(
9689 std::mem::size_of::<DeviceGetCapabilitiesResponse<'_>>(),
9690 16
9691 );
9692 static_assertions::const_assert_eq!(
9693 std::mem::align_of::<DeviceGetCapabilitiesResponse<'_>>(),
9694 8
9695 );
9696
9697 static_assertions::const_assert_eq!(
9698 std::mem::offset_of!(DeviceGetCapabilitiesResponse<'_>, offsets),
9699 0
9700 );
9701
9702 impl ::fidl_next::Constrained for DeviceGetCapabilitiesResponse<'_> {
9703 type Constraint = ();
9704
9705 fn validate(
9706 _: ::fidl_next::Slot<'_, Self>,
9707 _: Self::Constraint,
9708 ) -> Result<(), ::fidl_next::ValidationError> {
9709 Ok(())
9710 }
9711 }
9712
9713 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesResponse<'static> {
9714 type Narrowed<'de> = DeviceGetCapabilitiesResponse<'de>;
9715
9716 #[inline]
9717 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9718 ::fidl_next::munge! {
9719 let Self {
9720 offsets,
9721
9722 } = &mut *out_;
9723 }
9724
9725 ::fidl_next::Wire::zero_padding(offsets);
9726 }
9727 }
9728
9729 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesResponse<'de>
9730 where
9731 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9732 ___D: ::fidl_next::Decoder<'de>,
9733 {
9734 fn decode(
9735 slot_: ::fidl_next::Slot<'_, Self>,
9736 decoder_: &mut ___D,
9737 _: (),
9738 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9739 ::fidl_next::munge! {
9740 let Self {
9741 mut offsets,
9742
9743 } = slot_;
9744 }
9745
9746 let _field = offsets.as_mut();
9747 ::fidl_next::Constrained::validate(_field, (32, ()))?;
9748 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
9749
9750 let offsets = unsafe { offsets.deref_unchecked() };
9751
9752 if offsets.len() > 32 {
9753 return Err(::fidl_next::DecodeError::VectorTooLong {
9754 size: offsets.len() as u64,
9755 limit: 32,
9756 });
9757 }
9758
9759 Ok(())
9760 }
9761 }
9762
9763 impl<'de> ::fidl_next::IntoNatural for DeviceGetCapabilitiesResponse<'de> {
9764 type Natural = crate::natural::DeviceGetCapabilitiesResponse;
9765 }
9766
9767 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9769 #[repr(transparent)]
9770 pub struct ExtendedCapabilityId {
9771 pub(crate) value: ::fidl_next::wire::Uint16,
9772 }
9773
9774 impl ::fidl_next::Constrained for ExtendedCapabilityId {
9775 type Constraint = ();
9776
9777 fn validate(
9778 _: ::fidl_next::Slot<'_, Self>,
9779 _: Self::Constraint,
9780 ) -> Result<(), ::fidl_next::ValidationError> {
9781 Ok(())
9782 }
9783 }
9784
9785 unsafe impl ::fidl_next::Wire for ExtendedCapabilityId {
9786 type Narrowed<'de> = Self;
9787
9788 #[inline]
9789 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9790 }
9792 }
9793
9794 impl ExtendedCapabilityId {
9795 pub const NULL: ExtendedCapabilityId =
9796 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(0) };
9797
9798 pub const ADVANCED_ERROR_REPORTING: ExtendedCapabilityId =
9799 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(1) };
9800
9801 pub const VIRTUAL_CHANNEL_NO_MFVC: ExtendedCapabilityId =
9802 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(2) };
9803
9804 pub const DEVICE_SERIAL_NUMBER: ExtendedCapabilityId =
9805 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(3) };
9806
9807 pub const POWER_BUDGETING: ExtendedCapabilityId =
9808 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(4) };
9809
9810 pub const ROOT_COMPLEX_LINK_DECLARATION: ExtendedCapabilityId =
9811 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(5) };
9812
9813 pub const ROOT_COMPLEX_INTERNAL_LINK_CONTROL: ExtendedCapabilityId =
9814 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(6) };
9815
9816 pub const ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION: ExtendedCapabilityId =
9817 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(7) };
9818
9819 pub const MULTI_FUNCTION_VIRTUAL_CHANNEL: ExtendedCapabilityId =
9820 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(8) };
9821
9822 pub const VIRTUAL_CHANNEL: ExtendedCapabilityId =
9823 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(9) };
9824
9825 pub const RCRB: ExtendedCapabilityId =
9826 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(10) };
9827
9828 pub const VENDOR: ExtendedCapabilityId =
9829 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(11) };
9830
9831 pub const CAC: ExtendedCapabilityId =
9832 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(12) };
9833
9834 pub const ACS: ExtendedCapabilityId =
9835 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(13) };
9836
9837 pub const ARI: ExtendedCapabilityId =
9838 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(14) };
9839
9840 pub const ATS: ExtendedCapabilityId =
9841 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(15) };
9842
9843 pub const SR_IOV: ExtendedCapabilityId =
9844 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(16) };
9845
9846 pub const MR_IOV: ExtendedCapabilityId =
9847 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(17) };
9848
9849 pub const MULTICAST: ExtendedCapabilityId =
9850 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(18) };
9851
9852 pub const PRI: ExtendedCapabilityId =
9853 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(19) };
9854
9855 pub const ENHANCED_ALLOCATION: ExtendedCapabilityId =
9856 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(20) };
9857
9858 pub const RESIZABLE_BAR: ExtendedCapabilityId =
9859 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(21) };
9860
9861 pub const DYNAMIC_POWER_ALLOCATION: ExtendedCapabilityId =
9862 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(22) };
9863
9864 pub const TPH: ExtendedCapabilityId =
9865 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(23) };
9866
9867 pub const LATENCY_TOLERANCE_REPORTING: ExtendedCapabilityId =
9868 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(24) };
9869
9870 pub const SECONDARY_PCI_EXPRESS: ExtendedCapabilityId =
9871 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(25) };
9872
9873 pub const PMUX: ExtendedCapabilityId =
9874 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(26) };
9875
9876 pub const PASID: ExtendedCapabilityId =
9877 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(27) };
9878
9879 pub const LNR: ExtendedCapabilityId =
9880 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(28) };
9881
9882 pub const DPC: ExtendedCapabilityId =
9883 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(29) };
9884
9885 pub const L1_PM_SUBSTATES: ExtendedCapabilityId =
9886 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(30) };
9887
9888 pub const PRECISION_TIME_MEASUREMENT: ExtendedCapabilityId =
9889 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(31) };
9890
9891 pub const MPCIE: ExtendedCapabilityId =
9892 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(32) };
9893
9894 pub const FRS_QUEUEING: ExtendedCapabilityId =
9895 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(33) };
9896
9897 pub const READINESS_TIME_REPORTING: ExtendedCapabilityId =
9898 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(34) };
9899
9900 pub const DESIGNATED_VENDOR: ExtendedCapabilityId =
9901 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(35) };
9902
9903 pub const VF_RESIZABLE_BAR: ExtendedCapabilityId =
9904 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(36) };
9905
9906 pub const DATA_LINK_FEATURE: ExtendedCapabilityId =
9907 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(37) };
9908
9909 pub const PHYSICAL_LAYER_16: ExtendedCapabilityId =
9910 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(38) };
9911
9912 pub const LANE_MARGINING_AT_RECEIVER: ExtendedCapabilityId =
9913 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(39) };
9914
9915 pub const HIERARCHY_ID: ExtendedCapabilityId =
9916 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(40) };
9917
9918 pub const NATIVE_PCIE_ENCLOSURE: ExtendedCapabilityId =
9919 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(41) };
9920
9921 pub const PHYSICAL_LAYER_32: ExtendedCapabilityId =
9922 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(42) };
9923
9924 pub const ALTERNATE_PROTOCOL: ExtendedCapabilityId =
9925 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(43) };
9926
9927 pub const SYSTEM_FIRMWARE_INTERMEDIARY: ExtendedCapabilityId =
9928 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(44) };
9929 }
9930
9931 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapabilityId
9932 where
9933 ___D: ?Sized,
9934 {
9935 fn decode(
9936 slot: ::fidl_next::Slot<'_, Self>,
9937 _: &mut ___D,
9938 _: (),
9939 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9940 Ok(())
9941 }
9942 }
9943
9944 impl ::core::convert::From<crate::natural::ExtendedCapabilityId> for ExtendedCapabilityId {
9945 fn from(natural: crate::natural::ExtendedCapabilityId) -> Self {
9946 match natural {
9947
9948 crate::natural::ExtendedCapabilityId::Null => ExtendedCapabilityId::NULL,
9949
9950 crate::natural::ExtendedCapabilityId::AdvancedErrorReporting => ExtendedCapabilityId::ADVANCED_ERROR_REPORTING,
9951
9952 crate::natural::ExtendedCapabilityId::VirtualChannelNoMfvc => ExtendedCapabilityId::VIRTUAL_CHANNEL_NO_MFVC,
9953
9954 crate::natural::ExtendedCapabilityId::DeviceSerialNumber => ExtendedCapabilityId::DEVICE_SERIAL_NUMBER,
9955
9956 crate::natural::ExtendedCapabilityId::PowerBudgeting => ExtendedCapabilityId::POWER_BUDGETING,
9957
9958 crate::natural::ExtendedCapabilityId::RootComplexLinkDeclaration => ExtendedCapabilityId::ROOT_COMPLEX_LINK_DECLARATION,
9959
9960 crate::natural::ExtendedCapabilityId::RootComplexInternalLinkControl => ExtendedCapabilityId::ROOT_COMPLEX_INTERNAL_LINK_CONTROL,
9961
9962 crate::natural::ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => ExtendedCapabilityId::ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION,
9963
9964 crate::natural::ExtendedCapabilityId::MultiFunctionVirtualChannel => ExtendedCapabilityId::MULTI_FUNCTION_VIRTUAL_CHANNEL,
9965
9966 crate::natural::ExtendedCapabilityId::VirtualChannel => ExtendedCapabilityId::VIRTUAL_CHANNEL,
9967
9968 crate::natural::ExtendedCapabilityId::Rcrb => ExtendedCapabilityId::RCRB,
9969
9970 crate::natural::ExtendedCapabilityId::Vendor => ExtendedCapabilityId::VENDOR,
9971
9972 crate::natural::ExtendedCapabilityId::Cac => ExtendedCapabilityId::CAC,
9973
9974 crate::natural::ExtendedCapabilityId::Acs => ExtendedCapabilityId::ACS,
9975
9976 crate::natural::ExtendedCapabilityId::Ari => ExtendedCapabilityId::ARI,
9977
9978 crate::natural::ExtendedCapabilityId::Ats => ExtendedCapabilityId::ATS,
9979
9980 crate::natural::ExtendedCapabilityId::SrIov => ExtendedCapabilityId::SR_IOV,
9981
9982 crate::natural::ExtendedCapabilityId::MrIov => ExtendedCapabilityId::MR_IOV,
9983
9984 crate::natural::ExtendedCapabilityId::Multicast => ExtendedCapabilityId::MULTICAST,
9985
9986 crate::natural::ExtendedCapabilityId::Pri => ExtendedCapabilityId::PRI,
9987
9988 crate::natural::ExtendedCapabilityId::EnhancedAllocation => ExtendedCapabilityId::ENHANCED_ALLOCATION,
9989
9990 crate::natural::ExtendedCapabilityId::ResizableBar => ExtendedCapabilityId::RESIZABLE_BAR,
9991
9992 crate::natural::ExtendedCapabilityId::DynamicPowerAllocation => ExtendedCapabilityId::DYNAMIC_POWER_ALLOCATION,
9993
9994 crate::natural::ExtendedCapabilityId::Tph => ExtendedCapabilityId::TPH,
9995
9996 crate::natural::ExtendedCapabilityId::LatencyToleranceReporting => ExtendedCapabilityId::LATENCY_TOLERANCE_REPORTING,
9997
9998 crate::natural::ExtendedCapabilityId::SecondaryPciExpress => ExtendedCapabilityId::SECONDARY_PCI_EXPRESS,
9999
10000 crate::natural::ExtendedCapabilityId::Pmux => ExtendedCapabilityId::PMUX,
10001
10002 crate::natural::ExtendedCapabilityId::Pasid => ExtendedCapabilityId::PASID,
10003
10004 crate::natural::ExtendedCapabilityId::Lnr => ExtendedCapabilityId::LNR,
10005
10006 crate::natural::ExtendedCapabilityId::Dpc => ExtendedCapabilityId::DPC,
10007
10008 crate::natural::ExtendedCapabilityId::L1PmSubstates => ExtendedCapabilityId::L1_PM_SUBSTATES,
10009
10010 crate::natural::ExtendedCapabilityId::PrecisionTimeMeasurement => ExtendedCapabilityId::PRECISION_TIME_MEASUREMENT,
10011
10012 crate::natural::ExtendedCapabilityId::Mpcie => ExtendedCapabilityId::MPCIE,
10013
10014 crate::natural::ExtendedCapabilityId::FrsQueueing => ExtendedCapabilityId::FRS_QUEUEING,
10015
10016 crate::natural::ExtendedCapabilityId::ReadinessTimeReporting => ExtendedCapabilityId::READINESS_TIME_REPORTING,
10017
10018 crate::natural::ExtendedCapabilityId::DesignatedVendor => ExtendedCapabilityId::DESIGNATED_VENDOR,
10019
10020 crate::natural::ExtendedCapabilityId::VfResizableBar => ExtendedCapabilityId::VF_RESIZABLE_BAR,
10021
10022 crate::natural::ExtendedCapabilityId::DataLinkFeature => ExtendedCapabilityId::DATA_LINK_FEATURE,
10023
10024 crate::natural::ExtendedCapabilityId::PhysicalLayer16 => ExtendedCapabilityId::PHYSICAL_LAYER_16,
10025
10026 crate::natural::ExtendedCapabilityId::LaneMarginingAtReceiver => ExtendedCapabilityId::LANE_MARGINING_AT_RECEIVER,
10027
10028 crate::natural::ExtendedCapabilityId::HierarchyId => ExtendedCapabilityId::HIERARCHY_ID,
10029
10030 crate::natural::ExtendedCapabilityId::NativePcieEnclosure => ExtendedCapabilityId::NATIVE_PCIE_ENCLOSURE,
10031
10032 crate::natural::ExtendedCapabilityId::PhysicalLayer32 => ExtendedCapabilityId::PHYSICAL_LAYER_32,
10033
10034 crate::natural::ExtendedCapabilityId::AlternateProtocol => ExtendedCapabilityId::ALTERNATE_PROTOCOL,
10035
10036 crate::natural::ExtendedCapabilityId::SystemFirmwareIntermediary => ExtendedCapabilityId::SYSTEM_FIRMWARE_INTERMEDIARY,
10037
10038
10039 crate::natural::ExtendedCapabilityId::UnknownOrdinal_(value) => ExtendedCapabilityId {
10040 value: ::fidl_next::wire::Uint16::from(value),
10041 }
10042
10043 }
10044 }
10045 }
10046
10047 impl ::fidl_next::IntoNatural for ExtendedCapabilityId {
10048 type Natural = crate::natural::ExtendedCapabilityId;
10049 }
10050
10051 #[derive(Clone, Debug)]
10053 #[repr(C)]
10054 pub struct DeviceGetExtendedCapabilitiesRequest {
10055 pub id: crate::wire::ExtendedCapabilityId,
10056 }
10057
10058 static_assertions::const_assert_eq!(
10059 std::mem::size_of::<DeviceGetExtendedCapabilitiesRequest>(),
10060 2
10061 );
10062 static_assertions::const_assert_eq!(
10063 std::mem::align_of::<DeviceGetExtendedCapabilitiesRequest>(),
10064 2
10065 );
10066
10067 static_assertions::const_assert_eq!(
10068 std::mem::offset_of!(DeviceGetExtendedCapabilitiesRequest, id),
10069 0
10070 );
10071
10072 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesRequest {
10073 type Constraint = ();
10074
10075 fn validate(
10076 _: ::fidl_next::Slot<'_, Self>,
10077 _: Self::Constraint,
10078 ) -> Result<(), ::fidl_next::ValidationError> {
10079 Ok(())
10080 }
10081 }
10082
10083 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesRequest {
10084 type Narrowed<'de> = DeviceGetExtendedCapabilitiesRequest;
10085
10086 #[inline]
10087 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10088 ::fidl_next::munge! {
10089 let Self {
10090 id,
10091
10092 } = &mut *out_;
10093 }
10094
10095 ::fidl_next::Wire::zero_padding(id);
10096 }
10097 }
10098
10099 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesRequest
10100 where
10101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10102 {
10103 fn decode(
10104 slot_: ::fidl_next::Slot<'_, Self>,
10105 decoder_: &mut ___D,
10106 _: (),
10107 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10108 ::fidl_next::munge! {
10109 let Self {
10110 mut id,
10111
10112 } = slot_;
10113 }
10114
10115 let _field = id.as_mut();
10116
10117 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10118
10119 Ok(())
10120 }
10121 }
10122
10123 impl ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesRequest {
10124 type Natural = crate::natural::DeviceGetExtendedCapabilitiesRequest;
10125 }
10126
10127 #[derive(Debug)]
10129 #[repr(C)]
10130 pub struct DeviceGetExtendedCapabilitiesResponse<'de> {
10131 pub offsets: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
10132 }
10133
10134 static_assertions::const_assert_eq!(
10135 std::mem::size_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10136 16
10137 );
10138 static_assertions::const_assert_eq!(
10139 std::mem::align_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10140 8
10141 );
10142
10143 static_assertions::const_assert_eq!(
10144 std::mem::offset_of!(DeviceGetExtendedCapabilitiesResponse<'_>, offsets),
10145 0
10146 );
10147
10148 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesResponse<'_> {
10149 type Constraint = ();
10150
10151 fn validate(
10152 _: ::fidl_next::Slot<'_, Self>,
10153 _: Self::Constraint,
10154 ) -> Result<(), ::fidl_next::ValidationError> {
10155 Ok(())
10156 }
10157 }
10158
10159 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesResponse<'static> {
10160 type Narrowed<'de> = DeviceGetExtendedCapabilitiesResponse<'de>;
10161
10162 #[inline]
10163 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10164 ::fidl_next::munge! {
10165 let Self {
10166 offsets,
10167
10168 } = &mut *out_;
10169 }
10170
10171 ::fidl_next::Wire::zero_padding(offsets);
10172 }
10173 }
10174
10175 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesResponse<'de>
10176 where
10177 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10178 ___D: ::fidl_next::Decoder<'de>,
10179 {
10180 fn decode(
10181 slot_: ::fidl_next::Slot<'_, Self>,
10182 decoder_: &mut ___D,
10183 _: (),
10184 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10185 ::fidl_next::munge! {
10186 let Self {
10187 mut offsets,
10188
10189 } = slot_;
10190 }
10191
10192 let _field = offsets.as_mut();
10193 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10194 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
10195
10196 let offsets = unsafe { offsets.deref_unchecked() };
10197
10198 if offsets.len() > 32 {
10199 return Err(::fidl_next::DecodeError::VectorTooLong {
10200 size: offsets.len() as u64,
10201 limit: 32,
10202 });
10203 }
10204
10205 Ok(())
10206 }
10207 }
10208
10209 impl<'de> ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesResponse<'de> {
10210 type Natural = crate::natural::DeviceGetExtendedCapabilitiesResponse;
10211 }
10212
10213 #[derive(Clone, Debug)]
10215 #[repr(C)]
10216 pub struct DeviceGetBtiRequest {
10217 pub index: ::fidl_next::wire::Uint32,
10218 }
10219
10220 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBtiRequest>(), 4);
10221 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBtiRequest>(), 4);
10222
10223 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBtiRequest, index), 0);
10224
10225 impl ::fidl_next::Constrained for DeviceGetBtiRequest {
10226 type Constraint = ();
10227
10228 fn validate(
10229 _: ::fidl_next::Slot<'_, Self>,
10230 _: Self::Constraint,
10231 ) -> Result<(), ::fidl_next::ValidationError> {
10232 Ok(())
10233 }
10234 }
10235
10236 unsafe impl ::fidl_next::Wire for DeviceGetBtiRequest {
10237 type Narrowed<'de> = DeviceGetBtiRequest;
10238
10239 #[inline]
10240 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10241 ::fidl_next::munge! {
10242 let Self {
10243 index,
10244
10245 } = &mut *out_;
10246 }
10247
10248 ::fidl_next::Wire::zero_padding(index);
10249 }
10250 }
10251
10252 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBtiRequest
10253 where
10254 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10255 {
10256 fn decode(
10257 slot_: ::fidl_next::Slot<'_, Self>,
10258 decoder_: &mut ___D,
10259 _: (),
10260 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10261 ::fidl_next::munge! {
10262 let Self {
10263 mut index,
10264
10265 } = slot_;
10266 }
10267
10268 let _field = index.as_mut();
10269
10270 ::fidl_next::Decode::decode(index.as_mut(), decoder_, ())?;
10271
10272 Ok(())
10273 }
10274 }
10275
10276 impl ::fidl_next::IntoNatural for DeviceGetBtiRequest {
10277 type Natural = crate::natural::DeviceGetBtiRequest;
10278 }
10279
10280 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10282 #[repr(transparent)]
10283 pub struct InterruptMode {
10284 pub(crate) value: u8,
10285 }
10286
10287 impl ::fidl_next::Constrained for InterruptMode {
10288 type Constraint = ();
10289
10290 fn validate(
10291 _: ::fidl_next::Slot<'_, Self>,
10292 _: Self::Constraint,
10293 ) -> Result<(), ::fidl_next::ValidationError> {
10294 Ok(())
10295 }
10296 }
10297
10298 unsafe impl ::fidl_next::Wire for InterruptMode {
10299 type Narrowed<'de> = Self;
10300
10301 #[inline]
10302 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10303 }
10305 }
10306
10307 impl InterruptMode {
10308 pub const DISABLED: InterruptMode = InterruptMode { value: 0 };
10309
10310 pub const LEGACY: InterruptMode = InterruptMode { value: 1 };
10311
10312 pub const LEGACY_NOACK: InterruptMode = InterruptMode { value: 2 };
10313
10314 pub const MSI: InterruptMode = InterruptMode { value: 3 };
10315
10316 pub const MSI_X: InterruptMode = InterruptMode { value: 4 };
10317 }
10318
10319 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptMode
10320 where
10321 ___D: ?Sized,
10322 {
10323 fn decode(
10324 slot: ::fidl_next::Slot<'_, Self>,
10325 _: &mut ___D,
10326 _: (),
10327 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10328 Ok(())
10329 }
10330 }
10331
10332 impl ::core::convert::From<crate::natural::InterruptMode> for InterruptMode {
10333 fn from(natural: crate::natural::InterruptMode) -> Self {
10334 match natural {
10335 crate::natural::InterruptMode::Disabled => InterruptMode::DISABLED,
10336
10337 crate::natural::InterruptMode::Legacy => InterruptMode::LEGACY,
10338
10339 crate::natural::InterruptMode::LegacyNoack => InterruptMode::LEGACY_NOACK,
10340
10341 crate::natural::InterruptMode::Msi => InterruptMode::MSI,
10342
10343 crate::natural::InterruptMode::MsiX => InterruptMode::MSI_X,
10344
10345 crate::natural::InterruptMode::UnknownOrdinal_(value) => {
10346 InterruptMode { value: u8::from(value) }
10347 }
10348 }
10349 }
10350 }
10351
10352 impl ::fidl_next::IntoNatural for InterruptMode {
10353 type Natural = crate::natural::InterruptMode;
10354 }
10355
10356 #[derive(Clone, Debug)]
10358 #[repr(C)]
10359 pub struct DeviceSetInterruptModeRequest {
10360 pub mode: crate::wire::InterruptMode,
10361
10362 pub requested_irq_count: ::fidl_next::wire::Uint32,
10363 }
10364
10365 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetInterruptModeRequest>(), 8);
10366 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetInterruptModeRequest>(), 4);
10367
10368 static_assertions::const_assert_eq!(
10369 std::mem::offset_of!(DeviceSetInterruptModeRequest, mode),
10370 0
10371 );
10372
10373 static_assertions::const_assert_eq!(
10374 std::mem::offset_of!(DeviceSetInterruptModeRequest, requested_irq_count),
10375 4
10376 );
10377
10378 impl ::fidl_next::Constrained for DeviceSetInterruptModeRequest {
10379 type Constraint = ();
10380
10381 fn validate(
10382 _: ::fidl_next::Slot<'_, Self>,
10383 _: Self::Constraint,
10384 ) -> Result<(), ::fidl_next::ValidationError> {
10385 Ok(())
10386 }
10387 }
10388
10389 unsafe impl ::fidl_next::Wire for DeviceSetInterruptModeRequest {
10390 type Narrowed<'de> = DeviceSetInterruptModeRequest;
10391
10392 #[inline]
10393 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10394 ::fidl_next::munge! {
10395 let Self {
10396 mode,
10397 requested_irq_count,
10398
10399 } = &mut *out_;
10400 }
10401
10402 ::fidl_next::Wire::zero_padding(mode);
10403
10404 ::fidl_next::Wire::zero_padding(requested_irq_count);
10405
10406 unsafe {
10407 out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
10408 }
10409 }
10410 }
10411
10412 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetInterruptModeRequest
10413 where
10414 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10415 {
10416 fn decode(
10417 slot_: ::fidl_next::Slot<'_, Self>,
10418 decoder_: &mut ___D,
10419 _: (),
10420 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10421 if slot_.as_bytes()[1..4] != [0u8; 3] {
10422 return Err(::fidl_next::DecodeError::InvalidPadding);
10423 }
10424
10425 ::fidl_next::munge! {
10426 let Self {
10427 mut mode,
10428 mut requested_irq_count,
10429
10430 } = slot_;
10431 }
10432
10433 let _field = mode.as_mut();
10434
10435 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
10436
10437 let _field = requested_irq_count.as_mut();
10438
10439 ::fidl_next::Decode::decode(requested_irq_count.as_mut(), decoder_, ())?;
10440
10441 Ok(())
10442 }
10443 }
10444
10445 impl ::fidl_next::IntoNatural for DeviceSetInterruptModeRequest {
10446 type Natural = crate::natural::DeviceSetInterruptModeRequest;
10447 }
10448
10449 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10451 #[repr(transparent)]
10452 pub struct HeaderType {
10453 pub(crate) value: u8,
10454 }
10455
10456 impl ::fidl_next::Constrained for HeaderType {
10457 type Constraint = ();
10458
10459 fn validate(
10460 _: ::fidl_next::Slot<'_, Self>,
10461 _: Self::Constraint,
10462 ) -> Result<(), ::fidl_next::ValidationError> {
10463 Ok(())
10464 }
10465 }
10466
10467 unsafe impl ::fidl_next::Wire for HeaderType {
10468 type Narrowed<'de> = Self;
10469
10470 #[inline]
10471 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10472 }
10474 }
10475
10476 impl HeaderType {
10477 pub const STANDARD: HeaderType = HeaderType { value: 0 };
10478
10479 pub const BRIDGE: HeaderType = HeaderType { value: 1 };
10480
10481 pub const CARD_BUS: HeaderType = HeaderType { value: 2 };
10482
10483 pub const MASK: HeaderType = HeaderType { value: 127 };
10484
10485 pub const MULTI_FN: HeaderType = HeaderType { value: 128 };
10486 }
10487
10488 unsafe impl<___D> ::fidl_next::Decode<___D> for HeaderType
10489 where
10490 ___D: ?Sized,
10491 {
10492 fn decode(
10493 slot: ::fidl_next::Slot<'_, Self>,
10494 _: &mut ___D,
10495 _: (),
10496 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10497 Ok(())
10498 }
10499 }
10500
10501 impl ::core::convert::From<crate::natural::HeaderType> for HeaderType {
10502 fn from(natural: crate::natural::HeaderType) -> Self {
10503 match natural {
10504 crate::natural::HeaderType::Standard => HeaderType::STANDARD,
10505
10506 crate::natural::HeaderType::Bridge => HeaderType::BRIDGE,
10507
10508 crate::natural::HeaderType::CardBus => HeaderType::CARD_BUS,
10509
10510 crate::natural::HeaderType::Mask => HeaderType::MASK,
10511
10512 crate::natural::HeaderType::MultiFn => HeaderType::MULTI_FN,
10513
10514 crate::natural::HeaderType::UnknownOrdinal_(value) => {
10515 HeaderType { value: u8::from(value) }
10516 }
10517 }
10518 }
10519 }
10520
10521 impl ::fidl_next::IntoNatural for HeaderType {
10522 type Natural = crate::natural::HeaderType;
10523 }
10524
10525 #[derive(Clone, Copy, Debug)]
10527 #[repr(transparent)]
10528 pub struct Status {
10529 pub(crate) value: ::fidl_next::wire::Uint16,
10530 }
10531
10532 impl ::fidl_next::Constrained for Status {
10533 type Constraint = ();
10534
10535 fn validate(
10536 _: ::fidl_next::Slot<'_, Self>,
10537 _: Self::Constraint,
10538 ) -> Result<(), ::fidl_next::ValidationError> {
10539 Ok(())
10540 }
10541 }
10542
10543 unsafe impl ::fidl_next::Wire for Status {
10544 type Narrowed<'de> = Self;
10545
10546 #[inline]
10547 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10548 }
10550 }
10551
10552 unsafe impl<___D> ::fidl_next::Decode<___D> for Status
10553 where
10554 ___D: ?Sized,
10555 {
10556 fn decode(
10557 slot: ::fidl_next::Slot<'_, Self>,
10558 _: &mut ___D,
10559 _: (),
10560 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10561 Ok(())
10562 }
10563 }
10564
10565 impl ::core::convert::From<crate::natural::Status> for Status {
10566 fn from(natural: crate::natural::Status) -> Self {
10567 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
10568 }
10569 }
10570
10571 impl ::fidl_next::IntoNatural for Status {
10572 type Natural = crate::natural::Status;
10573 }
10574}
10575
10576pub mod wire_optional {}
10577
10578pub mod generic {
10579
10580 pub struct Address<T0, T1, T2> {
10582 pub bus: T0,
10583
10584 pub device: T1,
10585
10586 pub function: T2,
10587 }
10588
10589 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Address, ___E>
10590 for Address<T0, T1, T2>
10591 where
10592 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10593 T0: ::fidl_next::Encode<u8, ___E>,
10594 T1: ::fidl_next::Encode<u8, ___E>,
10595 T2: ::fidl_next::Encode<u8, ___E>,
10596 {
10597 #[inline]
10598 fn encode(
10599 self,
10600 encoder_: &mut ___E,
10601 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
10602 _: (),
10603 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10604 ::fidl_next::munge! {
10605 let crate::wire::Address {
10606 bus,
10607 device,
10608 function,
10609
10610 } = out_;
10611 }
10612
10613 ::fidl_next::Encode::encode(self.bus, encoder_, bus, ())?;
10614
10615 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
10616
10617 ::fidl_next::Encode::encode(self.function, encoder_, function, ())?;
10618
10619 Ok(())
10620 }
10621 }
10622
10623 pub struct BaseAddress<T0, T1, T2, T3, T4, T5> {
10625 pub address: T0,
10626
10627 pub size: T1,
10628
10629 pub is_memory: T2,
10630
10631 pub is_prefetchable: T3,
10632
10633 pub is_64bit: T4,
10634
10635 pub id: T5,
10636 }
10637
10638 unsafe impl<___E, T0, T1, T2, T3, T4, T5> ::fidl_next::Encode<crate::wire::BaseAddress, ___E>
10639 for BaseAddress<T0, T1, T2, T3, T4, T5>
10640 where
10641 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10642 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10643 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10644 T2: ::fidl_next::Encode<bool, ___E>,
10645 T3: ::fidl_next::Encode<bool, ___E>,
10646 T4: ::fidl_next::Encode<bool, ___E>,
10647 T5: ::fidl_next::Encode<u8, ___E>,
10648 {
10649 #[inline]
10650 fn encode(
10651 self,
10652 encoder_: &mut ___E,
10653 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
10654 _: (),
10655 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10656 ::fidl_next::munge! {
10657 let crate::wire::BaseAddress {
10658 address,
10659 size,
10660 is_memory,
10661 is_prefetchable,
10662 is_64bit,
10663 id,
10664
10665 } = out_;
10666 }
10667
10668 ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;
10669
10670 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10671
10672 ::fidl_next::Encode::encode(self.is_memory, encoder_, is_memory, ())?;
10673
10674 ::fidl_next::Encode::encode(self.is_prefetchable, encoder_, is_prefetchable, ())?;
10675
10676 ::fidl_next::Encode::encode(self.is_64bit, encoder_, is_64bit, ())?;
10677
10678 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10679
10680 Ok(())
10681 }
10682 }
10683
10684 pub type UseIntxWorkaroundType = ();
10686
10687 pub struct HostBridgeInfo<T0, T1, T2, T3> {
10689 pub name: T0,
10690
10691 pub start_bus_number: T1,
10692
10693 pub end_bus_number: T2,
10694
10695 pub segment_group: T3,
10696 }
10697
10698 unsafe impl<___E, T0, T1, T2, T3>
10699 ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
10700 for HostBridgeInfo<T0, T1, T2, T3>
10701 where
10702 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10703 ___E: ::fidl_next::Encoder,
10704 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10705 T1: ::fidl_next::Encode<u8, ___E>,
10706 T2: ::fidl_next::Encode<u8, ___E>,
10707 T3: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10708 {
10709 #[inline]
10710 fn encode(
10711 self,
10712 encoder_: &mut ___E,
10713 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
10714 _: (),
10715 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10716 ::fidl_next::munge! {
10717 let crate::wire::HostBridgeInfo {
10718 name,
10719 start_bus_number,
10720 end_bus_number,
10721 segment_group,
10722
10723 } = out_;
10724 }
10725
10726 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
10727
10728 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
10729
10730 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
10731
10732 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
10733
10734 Ok(())
10735 }
10736 }
10737
10738 pub struct BusGetHostBridgeInfoResponse<T0> {
10740 pub info: T0,
10741 }
10742
10743 unsafe impl<___E, T0>
10744 ::fidl_next::Encode<crate::wire::BusGetHostBridgeInfoResponse<'static>, ___E>
10745 for BusGetHostBridgeInfoResponse<T0>
10746 where
10747 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10748 ___E: ::fidl_next::Encoder,
10749 T0: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
10750 {
10751 #[inline]
10752 fn encode(
10753 self,
10754 encoder_: &mut ___E,
10755 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetHostBridgeInfoResponse<'static>>,
10756 _: (),
10757 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10758 ::fidl_next::munge! {
10759 let crate::wire::BusGetHostBridgeInfoResponse {
10760 info,
10761
10762 } = out_;
10763 }
10764
10765 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
10766
10767 Ok(())
10768 }
10769 }
10770
10771 pub struct Capability<T0, T1> {
10773 pub id: T0,
10774
10775 pub offset: T1,
10776 }
10777
10778 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability<T0, T1>
10779 where
10780 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10781 T0: ::fidl_next::Encode<u8, ___E>,
10782 T1: ::fidl_next::Encode<u8, ___E>,
10783 {
10784 #[inline]
10785 fn encode(
10786 self,
10787 encoder_: &mut ___E,
10788 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
10789 _: (),
10790 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10791 ::fidl_next::munge! {
10792 let crate::wire::Capability {
10793 id,
10794 offset,
10795
10796 } = out_;
10797 }
10798
10799 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10800
10801 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10802
10803 Ok(())
10804 }
10805 }
10806
10807 pub struct ExtendedCapability<T0, T1> {
10809 pub id: T0,
10810
10811 pub offset: T1,
10812 }
10813
10814 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
10815 for ExtendedCapability<T0, T1>
10816 where
10817 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10818 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10819 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
10820 {
10821 #[inline]
10822 fn encode(
10823 self,
10824 encoder_: &mut ___E,
10825 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
10826 _: (),
10827 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10828 ::fidl_next::munge! {
10829 let crate::wire::ExtendedCapability {
10830 id,
10831 offset,
10832
10833 } = out_;
10834 }
10835
10836 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
10837
10838 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10839
10840 Ok(())
10841 }
10842 }
10843
10844 pub struct PciDevice<T0, T1, T2, T3, T4, T5, T6> {
10846 pub base_addresses: T0,
10847
10848 pub capabilities: T1,
10849
10850 pub ext_capabilities: T2,
10851
10852 pub config: T3,
10853
10854 pub bus_id: T4,
10855
10856 pub device_id: T5,
10857
10858 pub function_id: T6,
10859 }
10860
10861 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
10862 ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>
10863 for PciDevice<T0, T1, T2, T3, T4, T5, T6>
10864 where
10865 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10866 ___E: ::fidl_next::Encoder,
10867 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::BaseAddress>, ___E>,
10868 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::Capability>, ___E>,
10869 T2: ::fidl_next::Encode<
10870 ::fidl_next::wire::Vector<'static, crate::wire::ExtendedCapability>,
10871 ___E,
10872 >,
10873 T3: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
10874 T4: ::fidl_next::Encode<u8, ___E>,
10875 T5: ::fidl_next::Encode<u8, ___E>,
10876 T6: ::fidl_next::Encode<u8, ___E>,
10877 {
10878 #[inline]
10879 fn encode(
10880 self,
10881 encoder_: &mut ___E,
10882 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
10883 _: (),
10884 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10885 ::fidl_next::munge! {
10886 let crate::wire::PciDevice {
10887 base_addresses,
10888 capabilities,
10889 ext_capabilities,
10890 config,
10891 bus_id,
10892 device_id,
10893 function_id,
10894
10895 } = out_;
10896 }
10897
10898 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
10899
10900 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
10901
10902 ::fidl_next::Encode::encode(
10903 self.ext_capabilities,
10904 encoder_,
10905 ext_capabilities,
10906 (32, ()),
10907 )?;
10908
10909 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
10910
10911 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
10912
10913 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
10914
10915 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
10916
10917 Ok(())
10918 }
10919 }
10920
10921 pub struct BusGetDevicesResponse<T0> {
10923 pub devices: T0,
10924 }
10925
10926 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusGetDevicesResponse<'static>, ___E>
10927 for BusGetDevicesResponse<T0>
10928 where
10929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10930 ___E: ::fidl_next::Encoder,
10931 T0: ::fidl_next::Encode<
10932 ::fidl_next::wire::Vector<'static, crate::wire::PciDevice<'static>>,
10933 ___E,
10934 >,
10935 {
10936 #[inline]
10937 fn encode(
10938 self,
10939 encoder_: &mut ___E,
10940 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusGetDevicesResponse<'static>>,
10941 _: (),
10942 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10943 ::fidl_next::munge! {
10944 let crate::wire::BusGetDevicesResponse {
10945 devices,
10946
10947 } = out_;
10948 }
10949
10950 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
10951
10952 Ok(())
10953 }
10954 }
10955
10956 pub struct BusReadBarRequest<T0, T1, T2, T3> {
10958 pub device: T0,
10959
10960 pub bar_id: T1,
10961
10962 pub offset: T2,
10963
10964 pub size: T3,
10965 }
10966
10967 unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<crate::wire::BusReadBarRequest, ___E>
10968 for BusReadBarRequest<T0, T1, T2, T3>
10969 where
10970 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10971 T0: ::fidl_next::Encode<crate::wire::Address, ___E>,
10972 T1: ::fidl_next::Encode<u8, ___E>,
10973 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10974 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10975 {
10976 #[inline]
10977 fn encode(
10978 self,
10979 encoder_: &mut ___E,
10980 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarRequest>,
10981 _: (),
10982 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10983 ::fidl_next::munge! {
10984 let crate::wire::BusReadBarRequest {
10985 device,
10986 bar_id,
10987 offset,
10988 size,
10989
10990 } = out_;
10991 }
10992
10993 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
10994
10995 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
10996
10997 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10998
10999 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
11000
11001 Ok(())
11002 }
11003 }
11004
11005 pub struct BusReadBarResponse<T0> {
11007 pub buffer: T0,
11008 }
11009
11010 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BusReadBarResponse<'static>, ___E>
11011 for BusReadBarResponse<T0>
11012 where
11013 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11014 ___E: ::fidl_next::Encoder,
11015 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11016 {
11017 #[inline]
11018 fn encode(
11019 self,
11020 encoder_: &mut ___E,
11021 out_: &mut ::core::mem::MaybeUninit<crate::wire::BusReadBarResponse<'static>>,
11022 _: (),
11023 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11024 ::fidl_next::munge! {
11025 let crate::wire::BusReadBarResponse {
11026 buffer,
11027
11028 } = out_;
11029 }
11030
11031 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
11032
11033 Ok(())
11034 }
11035 }
11036
11037 pub type Padding = ();
11039
11040 pub struct DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
11042 pub vendor_id: T0,
11043
11044 pub device_id: T1,
11045
11046 pub base_class: T2,
11047
11048 pub sub_class: T3,
11049
11050 pub program_interface: T4,
11051
11052 pub revision_id: T5,
11053
11054 pub bus_id: T6,
11055
11056 pub dev_id: T7,
11057
11058 pub func_id: T8,
11059
11060 pub padding: T9,
11061 }
11062
11063 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11064 ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>
11065 for DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11066 where
11067 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11068 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11069 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11070 T2: ::fidl_next::Encode<u8, ___E>,
11071 T3: ::fidl_next::Encode<u8, ___E>,
11072 T4: ::fidl_next::Encode<u8, ___E>,
11073 T5: ::fidl_next::Encode<u8, ___E>,
11074 T6: ::fidl_next::Encode<u8, ___E>,
11075 T7: ::fidl_next::Encode<u8, ___E>,
11076 T8: ::fidl_next::Encode<u8, ___E>,
11077 T9: ::fidl_next::Encode<crate::wire::Padding, ___E>,
11078 {
11079 #[inline]
11080 fn encode(
11081 self,
11082 encoder_: &mut ___E,
11083 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
11084 _: (),
11085 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11086 ::fidl_next::munge! {
11087 let crate::wire::DeviceInfo {
11088 vendor_id,
11089 device_id,
11090 base_class,
11091 sub_class,
11092 program_interface,
11093 revision_id,
11094 bus_id,
11095 dev_id,
11096 func_id,
11097 padding,
11098
11099 } = out_;
11100 }
11101
11102 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
11103
11104 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11105
11106 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
11107
11108 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
11109
11110 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
11111
11112 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
11113
11114 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11115
11116 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
11117
11118 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
11119
11120 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
11121
11122 Ok(())
11123 }
11124 }
11125
11126 pub struct DeviceGetDeviceInfoResponse<T0> {
11128 pub info: T0,
11129 }
11130
11131 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
11132 for DeviceGetDeviceInfoResponse<T0>
11133 where
11134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11135 T0: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
11136 {
11137 #[inline]
11138 fn encode(
11139 self,
11140 encoder_: &mut ___E,
11141 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
11142 _: (),
11143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11144 ::fidl_next::munge! {
11145 let crate::wire::DeviceGetDeviceInfoResponse {
11146 info,
11147
11148 } = out_;
11149 }
11150
11151 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
11152
11153 Ok(())
11154 }
11155 }
11156
11157 pub struct DeviceGetBarRequest<T0> {
11159 pub bar_id: T0,
11160 }
11161
11162 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
11163 for DeviceGetBarRequest<T0>
11164 where
11165 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11166 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11167 {
11168 #[inline]
11169 fn encode(
11170 self,
11171 encoder_: &mut ___E,
11172 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
11173 _: (),
11174 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11175 ::fidl_next::munge! {
11176 let crate::wire::DeviceGetBarRequest {
11177 bar_id,
11178
11179 } = out_;
11180 }
11181
11182 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11183
11184 Ok(())
11185 }
11186 }
11187
11188 pub struct DeviceSetBusMasteringRequest<T0> {
11190 pub enabled: T0,
11191 }
11192
11193 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
11194 for DeviceSetBusMasteringRequest<T0>
11195 where
11196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11197 T0: ::fidl_next::Encode<bool, ___E>,
11198 {
11199 #[inline]
11200 fn encode(
11201 self,
11202 encoder_: &mut ___E,
11203 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
11204 _: (),
11205 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11206 ::fidl_next::munge! {
11207 let crate::wire::DeviceSetBusMasteringRequest {
11208 enabled,
11209
11210 } = out_;
11211 }
11212
11213 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
11214
11215 Ok(())
11216 }
11217 }
11218
11219 pub type DeviceSetBusMasteringResponse = ();
11221
11222 pub type DeviceResetDeviceResponse = ();
11224
11225 pub type DeviceAckInterruptResponse = ();
11227
11228 pub struct DeviceMapInterruptRequest<T0> {
11230 pub which_irq: T0,
11231 }
11232
11233 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
11234 for DeviceMapInterruptRequest<T0>
11235 where
11236 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11237 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11238 {
11239 #[inline]
11240 fn encode(
11241 self,
11242 encoder_: &mut ___E,
11243 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
11244 _: (),
11245 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11246 ::fidl_next::munge! {
11247 let crate::wire::DeviceMapInterruptRequest {
11248 which_irq,
11249
11250 } = out_;
11251 }
11252
11253 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
11254
11255 Ok(())
11256 }
11257 }
11258
11259 pub struct InterruptModes<T0, T1, T2> {
11261 pub has_legacy: T0,
11262
11263 pub msi_count: T1,
11264
11265 pub msix_count: T2,
11266 }
11267
11268 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::InterruptModes, ___E>
11269 for InterruptModes<T0, T1, T2>
11270 where
11271 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11272 T0: ::fidl_next::Encode<bool, ___E>,
11273 T1: ::fidl_next::Encode<u8, ___E>,
11274 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11275 {
11276 #[inline]
11277 fn encode(
11278 self,
11279 encoder_: &mut ___E,
11280 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
11281 _: (),
11282 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11283 ::fidl_next::munge! {
11284 let crate::wire::InterruptModes {
11285 has_legacy,
11286 msi_count,
11287 msix_count,
11288
11289 } = out_;
11290 }
11291
11292 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
11293
11294 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
11295
11296 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
11297
11298 Ok(())
11299 }
11300 }
11301
11302 pub struct DeviceGetInterruptModesResponse<T0> {
11304 pub modes: T0,
11305 }
11306
11307 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
11308 for DeviceGetInterruptModesResponse<T0>
11309 where
11310 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11311 T0: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
11312 {
11313 #[inline]
11314 fn encode(
11315 self,
11316 encoder_: &mut ___E,
11317 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
11318 _: (),
11319 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11320 ::fidl_next::munge! {
11321 let crate::wire::DeviceGetInterruptModesResponse {
11322 modes,
11323
11324 } = out_;
11325 }
11326
11327 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
11328
11329 Ok(())
11330 }
11331 }
11332
11333 pub type DeviceSetInterruptModeResponse = ();
11335
11336 pub struct DeviceReadConfig8Request<T0> {
11338 pub offset: T0,
11339 }
11340
11341 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
11342 for DeviceReadConfig8Request<T0>
11343 where
11344 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11345 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11346 {
11347 #[inline]
11348 fn encode(
11349 self,
11350 encoder_: &mut ___E,
11351 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
11352 _: (),
11353 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11354 ::fidl_next::munge! {
11355 let crate::wire::DeviceReadConfig8Request {
11356 offset,
11357
11358 } = out_;
11359 }
11360
11361 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11362
11363 Ok(())
11364 }
11365 }
11366
11367 pub struct DeviceReadConfig8Response<T0> {
11369 pub value: T0,
11370 }
11371
11372 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
11373 for DeviceReadConfig8Response<T0>
11374 where
11375 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11376 T0: ::fidl_next::Encode<u8, ___E>,
11377 {
11378 #[inline]
11379 fn encode(
11380 self,
11381 encoder_: &mut ___E,
11382 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
11383 _: (),
11384 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11385 ::fidl_next::munge! {
11386 let crate::wire::DeviceReadConfig8Response {
11387 value,
11388
11389 } = out_;
11390 }
11391
11392 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11393
11394 Ok(())
11395 }
11396 }
11397
11398 pub struct DeviceReadConfig16Request<T0> {
11400 pub offset: T0,
11401 }
11402
11403 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
11404 for DeviceReadConfig16Request<T0>
11405 where
11406 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11407 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11408 {
11409 #[inline]
11410 fn encode(
11411 self,
11412 encoder_: &mut ___E,
11413 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
11414 _: (),
11415 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11416 ::fidl_next::munge! {
11417 let crate::wire::DeviceReadConfig16Request {
11418 offset,
11419
11420 } = out_;
11421 }
11422
11423 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11424
11425 Ok(())
11426 }
11427 }
11428
11429 pub struct DeviceReadConfig16Response<T0> {
11431 pub value: T0,
11432 }
11433
11434 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
11435 for DeviceReadConfig16Response<T0>
11436 where
11437 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11438 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11439 {
11440 #[inline]
11441 fn encode(
11442 self,
11443 encoder_: &mut ___E,
11444 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
11445 _: (),
11446 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11447 ::fidl_next::munge! {
11448 let crate::wire::DeviceReadConfig16Response {
11449 value,
11450
11451 } = out_;
11452 }
11453
11454 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11455
11456 Ok(())
11457 }
11458 }
11459
11460 pub struct DeviceReadConfig32Request<T0> {
11462 pub offset: T0,
11463 }
11464
11465 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
11466 for DeviceReadConfig32Request<T0>
11467 where
11468 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11469 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11470 {
11471 #[inline]
11472 fn encode(
11473 self,
11474 encoder_: &mut ___E,
11475 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
11476 _: (),
11477 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11478 ::fidl_next::munge! {
11479 let crate::wire::DeviceReadConfig32Request {
11480 offset,
11481
11482 } = out_;
11483 }
11484
11485 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11486
11487 Ok(())
11488 }
11489 }
11490
11491 pub struct DeviceReadConfig32Response<T0> {
11493 pub value: T0,
11494 }
11495
11496 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
11497 for DeviceReadConfig32Response<T0>
11498 where
11499 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11500 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11501 {
11502 #[inline]
11503 fn encode(
11504 self,
11505 encoder_: &mut ___E,
11506 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
11507 _: (),
11508 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11509 ::fidl_next::munge! {
11510 let crate::wire::DeviceReadConfig32Response {
11511 value,
11512
11513 } = out_;
11514 }
11515
11516 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11517
11518 Ok(())
11519 }
11520 }
11521
11522 pub struct DeviceWriteConfig8Request<T0, T1> {
11524 pub offset: T0,
11525
11526 pub value: T1,
11527 }
11528
11529 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
11530 for DeviceWriteConfig8Request<T0, T1>
11531 where
11532 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11533 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11534 T1: ::fidl_next::Encode<u8, ___E>,
11535 {
11536 #[inline]
11537 fn encode(
11538 self,
11539 encoder_: &mut ___E,
11540 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
11541 _: (),
11542 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11543 ::fidl_next::munge! {
11544 let crate::wire::DeviceWriteConfig8Request {
11545 offset,
11546 value,
11547
11548 } = out_;
11549 }
11550
11551 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11552
11553 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11554
11555 Ok(())
11556 }
11557 }
11558
11559 pub type DeviceWriteConfig8Response = ();
11561
11562 pub struct DeviceWriteConfig16Request<T0, T1> {
11564 pub offset: T0,
11565
11566 pub value: T1,
11567 }
11568
11569 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
11570 for DeviceWriteConfig16Request<T0, T1>
11571 where
11572 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11573 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11574 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11575 {
11576 #[inline]
11577 fn encode(
11578 self,
11579 encoder_: &mut ___E,
11580 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
11581 _: (),
11582 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11583 ::fidl_next::munge! {
11584 let crate::wire::DeviceWriteConfig16Request {
11585 offset,
11586 value,
11587
11588 } = out_;
11589 }
11590
11591 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11592
11593 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11594
11595 Ok(())
11596 }
11597 }
11598
11599 pub type DeviceWriteConfig16Response = ();
11601
11602 pub struct DeviceWriteConfig32Request<T0, T1> {
11604 pub offset: T0,
11605
11606 pub value: T1,
11607 }
11608
11609 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
11610 for DeviceWriteConfig32Request<T0, T1>
11611 where
11612 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11613 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11614 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11615 {
11616 #[inline]
11617 fn encode(
11618 self,
11619 encoder_: &mut ___E,
11620 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
11621 _: (),
11622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11623 ::fidl_next::munge! {
11624 let crate::wire::DeviceWriteConfig32Request {
11625 offset,
11626 value,
11627
11628 } = out_;
11629 }
11630
11631 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11632
11633 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11634
11635 Ok(())
11636 }
11637 }
11638
11639 pub type DeviceWriteConfig32Response = ();
11641
11642 pub struct DeviceGetCapabilitiesRequest<T0> {
11644 pub id: T0,
11645 }
11646
11647 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
11648 for DeviceGetCapabilitiesRequest<T0>
11649 where
11650 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11651 T0: ::fidl_next::Encode<crate::wire::CapabilityId, ___E>,
11652 {
11653 #[inline]
11654 fn encode(
11655 self,
11656 encoder_: &mut ___E,
11657 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
11658 _: (),
11659 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11660 ::fidl_next::munge! {
11661 let crate::wire::DeviceGetCapabilitiesRequest {
11662 id,
11663
11664 } = out_;
11665 }
11666
11667 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11668
11669 Ok(())
11670 }
11671 }
11672
11673 pub struct DeviceGetCapabilitiesResponse<T0> {
11675 pub offsets: T0,
11676 }
11677
11678 unsafe impl<___E, T0>
11679 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
11680 for DeviceGetCapabilitiesResponse<T0>
11681 where
11682 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11683 ___E: ::fidl_next::Encoder,
11684 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11685 {
11686 #[inline]
11687 fn encode(
11688 self,
11689 encoder_: &mut ___E,
11690 out_: &mut ::core::mem::MaybeUninit<
11691 crate::wire::DeviceGetCapabilitiesResponse<'static>,
11692 >,
11693 _: (),
11694 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11695 ::fidl_next::munge! {
11696 let crate::wire::DeviceGetCapabilitiesResponse {
11697 offsets,
11698
11699 } = out_;
11700 }
11701
11702 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11703
11704 Ok(())
11705 }
11706 }
11707
11708 pub struct DeviceGetExtendedCapabilitiesRequest<T0> {
11710 pub id: T0,
11711 }
11712
11713 unsafe impl<___E, T0>
11714 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
11715 for DeviceGetExtendedCapabilitiesRequest<T0>
11716 where
11717 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11718 T0: ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>,
11719 {
11720 #[inline]
11721 fn encode(
11722 self,
11723 encoder_: &mut ___E,
11724 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
11725 _: (),
11726 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11727 ::fidl_next::munge! {
11728 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
11729 id,
11730
11731 } = out_;
11732 }
11733
11734 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11735
11736 Ok(())
11737 }
11738 }
11739
11740 pub struct DeviceGetExtendedCapabilitiesResponse<T0> {
11742 pub offsets: T0,
11743 }
11744
11745 unsafe impl<___E, T0>
11746 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
11747 for DeviceGetExtendedCapabilitiesResponse<T0>
11748 where
11749 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11750 ___E: ::fidl_next::Encoder,
11751 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>, ___E>,
11752 {
11753 #[inline]
11754 fn encode(
11755 self,
11756 encoder_: &mut ___E,
11757 out_: &mut ::core::mem::MaybeUninit<
11758 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
11759 >,
11760 _: (),
11761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11762 ::fidl_next::munge! {
11763 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
11764 offsets,
11765
11766 } = out_;
11767 }
11768
11769 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
11770
11771 Ok(())
11772 }
11773 }
11774
11775 pub struct DeviceGetBtiRequest<T0> {
11777 pub index: T0,
11778 }
11779
11780 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
11781 for DeviceGetBtiRequest<T0>
11782 where
11783 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11784 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11785 {
11786 #[inline]
11787 fn encode(
11788 self,
11789 encoder_: &mut ___E,
11790 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
11791 _: (),
11792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11793 ::fidl_next::munge! {
11794 let crate::wire::DeviceGetBtiRequest {
11795 index,
11796
11797 } = out_;
11798 }
11799
11800 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
11801
11802 Ok(())
11803 }
11804 }
11805
11806 pub struct DeviceSetInterruptModeRequest<T0, T1> {
11808 pub mode: T0,
11809
11810 pub requested_irq_count: T1,
11811 }
11812
11813 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
11814 for DeviceSetInterruptModeRequest<T0, T1>
11815 where
11816 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11817 T0: ::fidl_next::Encode<crate::wire::InterruptMode, ___E>,
11818 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11819 {
11820 #[inline]
11821 fn encode(
11822 self,
11823 encoder_: &mut ___E,
11824 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
11825 _: (),
11826 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11827 ::fidl_next::munge! {
11828 let crate::wire::DeviceSetInterruptModeRequest {
11829 mode,
11830 requested_irq_count,
11831
11832 } = out_;
11833 }
11834
11835 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
11836
11837 ::fidl_next::Encode::encode(
11838 self.requested_irq_count,
11839 encoder_,
11840 requested_irq_count,
11841 (),
11842 )?;
11843
11844 Ok(())
11845 }
11846 }
11847}
11848
11849pub use self::natural::*;
11850
11851pub const BASE_ADDRESS_COUNT: u32 = 6 as u32;
11852
11853pub const BASE_CONFIG_SIZE: u32 = 256 as u32;
11854
11855pub const MAX_NAME_LEN: u32 = 32 as u32;
11856
11857pub const MAX_CAPABILITIES: u32 = 32 as u32;
11858
11859pub const MAX_EXT_CAPABILITIES: u32 = 32 as u32;
11860
11861pub const MAX_DEVICES: u32 = 64 as u32;
11862
11863#[doc = " The Bus service provides information about devices on a particular bus. It\n is used by clients like lspci, not drivers.\n"]
11865#[derive(PartialEq, Debug)]
11866pub struct Bus;
11867
11868impl ::fidl_next::Discoverable for Bus {
11869 const PROTOCOL_NAME: &'static str = "fuchsia.hardware.pci.Bus";
11870}
11871
11872#[cfg(target_os = "fuchsia")]
11873impl ::fidl_next::HasTransport for Bus {
11874 type Transport = ::fidl_next::fuchsia::zx::Channel;
11875}
11876
11877pub mod bus {
11878 pub mod prelude {
11879 pub use crate::{
11880 Bus, BusClientHandler, BusLocalClientHandler, BusLocalServerHandler, BusServerHandler,
11881 bus,
11882 };
11883
11884 pub use crate::natural::BusGetDevicesResponse;
11885
11886 pub use crate::natural::BusGetHostBridgeInfoResponse;
11887
11888 pub use crate::natural::BusReadBarRequest;
11889
11890 pub use crate::natural::BusReadBarResponse;
11891 }
11892
11893 pub struct GetHostBridgeInfo;
11894
11895 impl ::fidl_next::Method for GetHostBridgeInfo {
11896 const ORDINAL: u64 = 4175032687054816861;
11897 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11898 ::fidl_next::protocol::Flexibility::Strict;
11899
11900 type Protocol = crate::Bus;
11901
11902 type Request = ::fidl_next::wire::EmptyMessageBody;
11903 }
11904
11905 impl ::fidl_next::TwoWayMethod for GetHostBridgeInfo {
11906 type Response =
11907 ::fidl_next::wire::Strict<crate::wire::BusGetHostBridgeInfoResponse<'static>>;
11908 }
11909
11910 impl<___R> ::fidl_next::Respond<___R> for GetHostBridgeInfo {
11911 type Output = ::fidl_next::Strict<crate::generic::BusGetHostBridgeInfoResponse<___R>>;
11912
11913 fn respond(response: ___R) -> Self::Output {
11914 ::fidl_next::Strict(crate::generic::BusGetHostBridgeInfoResponse { info: response })
11915 }
11916 }
11917
11918 pub struct GetDevices;
11919
11920 impl ::fidl_next::Method for GetDevices {
11921 const ORDINAL: u64 = 3114700014429961362;
11922 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11923 ::fidl_next::protocol::Flexibility::Strict;
11924
11925 type Protocol = crate::Bus;
11926
11927 type Request = ::fidl_next::wire::EmptyMessageBody;
11928 }
11929
11930 impl ::fidl_next::TwoWayMethod for GetDevices {
11931 type Response = ::fidl_next::wire::Strict<crate::wire::BusGetDevicesResponse<'static>>;
11932 }
11933
11934 impl<___R> ::fidl_next::Respond<___R> for GetDevices {
11935 type Output = ::fidl_next::Strict<crate::generic::BusGetDevicesResponse<___R>>;
11936
11937 fn respond(response: ___R) -> Self::Output {
11938 ::fidl_next::Strict(crate::generic::BusGetDevicesResponse { devices: response })
11939 }
11940 }
11941
11942 pub struct ReadBar;
11943
11944 impl ::fidl_next::Method for ReadBar {
11945 const ORDINAL: u64 = 8759283232091687008;
11946 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11947 ::fidl_next::protocol::Flexibility::Strict;
11948
11949 type Protocol = crate::Bus;
11950
11951 type Request = crate::wire::BusReadBarRequest;
11952 }
11953
11954 impl ::fidl_next::TwoWayMethod for ReadBar {
11955 type Response = ::fidl_next::wire::Result<
11956 'static,
11957 crate::wire::BusReadBarResponse<'static>,
11958 ::fidl_next::wire::fuchsia::Status,
11959 >;
11960 }
11961
11962 impl<___R> ::fidl_next::Respond<___R> for ReadBar {
11963 type Output = ::core::result::Result<
11964 crate::generic::BusReadBarResponse<___R>,
11965 ::fidl_next::never::Never,
11966 >;
11967
11968 fn respond(response: ___R) -> Self::Output {
11969 ::core::result::Result::Ok(crate::generic::BusReadBarResponse { buffer: response })
11970 }
11971 }
11972
11973 impl<___R> ::fidl_next::RespondErr<___R> for ReadBar {
11974 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11975
11976 fn respond_err(response: ___R) -> Self::Output {
11977 ::core::result::Result::Err(response)
11978 }
11979 }
11980
11981 mod ___detail {
11982 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Bus
11983 where
11984 ___T: ::fidl_next::Transport,
11985 {
11986 type Client = BusClient<___T>;
11987 type Server = BusServer<___T>;
11988 }
11989
11990 #[repr(transparent)]
11992 pub struct BusClient<___T: ::fidl_next::Transport> {
11993 #[allow(dead_code)]
11994 client: ::fidl_next::protocol::Client<___T>,
11995 }
11996
11997 impl<___T> BusClient<___T>
11998 where
11999 ___T: ::fidl_next::Transport,
12000 {
12001 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12002 pub fn get_host_bridge_info(
12003 &self,
12004 ) -> ::fidl_next::TwoWayFuture<'_, super::GetHostBridgeInfo, ___T> {
12005 ::fidl_next::TwoWayFuture::from_untyped(
12006 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12007 4175032687054816861,
12008 <super::GetHostBridgeInfo as ::fidl_next::Method>::FLEXIBILITY,
12009 (),
12010 ),
12011 )
12012 }
12013
12014 #[doc = " Retrieve all Devices on the Bus.\n"]
12015 pub fn get_devices(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetDevices, ___T> {
12016 ::fidl_next::TwoWayFuture::from_untyped(
12017 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12018 3114700014429961362,
12019 <super::GetDevices as ::fidl_next::Method>::FLEXIBILITY,
12020 (),
12021 ),
12022 )
12023 }
12024
12025 #[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"]
12026 pub fn read_bar(
12027 &self,
12028
12029 device: impl ::fidl_next::Encode<
12030 crate::wire::Address,
12031 <___T as ::fidl_next::Transport>::SendBuffer,
12032 >,
12033
12034 bar_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
12035
12036 offset: impl ::fidl_next::Encode<
12037 ::fidl_next::wire::Uint64,
12038 <___T as ::fidl_next::Transport>::SendBuffer,
12039 >,
12040
12041 size: impl ::fidl_next::Encode<
12042 ::fidl_next::wire::Uint64,
12043 <___T as ::fidl_next::Transport>::SendBuffer,
12044 >,
12045 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12046 where
12047 <___T as ::fidl_next::Transport>::SendBuffer:
12048 ::fidl_next::encoder::InternalHandleEncoder,
12049 {
12050 self.read_bar_with(crate::generic::BusReadBarRequest {
12051 device,
12052
12053 bar_id,
12054
12055 offset,
12056
12057 size,
12058 })
12059 }
12060
12061 #[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"]
12062 pub fn read_bar_with<___R>(
12063 &self,
12064 request: ___R,
12065 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12066 where
12067 ___R: ::fidl_next::Encode<
12068 crate::wire::BusReadBarRequest,
12069 <___T as ::fidl_next::Transport>::SendBuffer,
12070 >,
12071 {
12072 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12073 8759283232091687008,
12074 <super::ReadBar as ::fidl_next::Method>::FLEXIBILITY,
12075 request,
12076 ))
12077 }
12078 }
12079
12080 #[repr(transparent)]
12082 pub struct BusServer<___T: ::fidl_next::Transport> {
12083 server: ::fidl_next::protocol::Server<___T>,
12084 }
12085
12086 impl<___T> BusServer<___T> where ___T: ::fidl_next::Transport {}
12087 }
12088}
12089
12090#[diagnostic::on_unimplemented(
12091 note = "If {Self} implements the non-local BusClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12092)]
12093
12094pub trait BusLocalClientHandler<
12098 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12099 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12100>
12101{
12102}
12103
12104impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Bus
12105where
12106 ___H: BusLocalClientHandler<___T>,
12107 ___T: ::fidl_next::Transport,
12108{
12109 async fn on_event(
12110 handler: &mut ___H,
12111 mut message: ::fidl_next::Message<___T>,
12112 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12113 match *message.header().ordinal {
12114 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12115 }
12116 }
12117}
12118
12119#[diagnostic::on_unimplemented(
12120 note = "If {Self} implements the non-local BusServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12121)]
12122
12123pub trait BusLocalServerHandler<
12127 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12128 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12129>
12130{
12131 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12132 fn get_host_bridge_info(
12133 &mut self,
12134
12135 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12136 ) -> impl ::core::future::Future<Output = ()>;
12137
12138 #[doc = " Retrieve all Devices on the Bus.\n"]
12139 fn get_devices(
12140 &mut self,
12141
12142 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12143 ) -> impl ::core::future::Future<Output = ()>;
12144
12145 #[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"]
12146 fn read_bar(
12147 &mut self,
12148
12149 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12150
12151 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12152 ) -> impl ::core::future::Future<Output = ()>;
12153}
12154
12155impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Bus
12156where
12157 ___H: BusLocalServerHandler<___T>,
12158 ___T: ::fidl_next::Transport,
12159 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12160 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12161 Constraint = (),
12162 >,
12163{
12164 async fn on_one_way(
12165 handler: &mut ___H,
12166 mut message: ::fidl_next::Message<___T>,
12167 ) -> ::core::result::Result<
12168 (),
12169 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12170 > {
12171 match *message.header().ordinal {
12172 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12173 }
12174 }
12175
12176 async fn on_two_way(
12177 handler: &mut ___H,
12178 mut message: ::fidl_next::Message<___T>,
12179 responder: ::fidl_next::protocol::Responder<___T>,
12180 ) -> ::core::result::Result<
12181 (),
12182 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12183 > {
12184 match *message.header().ordinal {
12185 4175032687054816861 => {
12186 let responder = ::fidl_next::Responder::from_untyped(responder);
12187
12188 handler.get_host_bridge_info(responder).await;
12189 Ok(())
12190 }
12191
12192 3114700014429961362 => {
12193 let responder = ::fidl_next::Responder::from_untyped(responder);
12194
12195 handler.get_devices(responder).await;
12196 Ok(())
12197 }
12198
12199 8759283232091687008 => {
12200 let responder = ::fidl_next::Responder::from_untyped(responder);
12201
12202 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12203 Ok(decoded) => {
12204 handler
12205 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12206 .await;
12207 Ok(())
12208 }
12209 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12210 ordinal: 8759283232091687008,
12211 error,
12212 }),
12213 }
12214 }
12215
12216 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12217 }
12218 }
12219}
12220
12221pub trait BusClientHandler<
12225 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12226 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12227>
12228{
12229}
12230
12231impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Bus
12232where
12233 ___H: BusClientHandler<___T> + ::core::marker::Send,
12234 ___T: ::fidl_next::Transport,
12235{
12236 async fn on_event(
12237 handler: &mut ___H,
12238 mut message: ::fidl_next::Message<___T>,
12239 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12240 match *message.header().ordinal {
12241 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12242 }
12243 }
12244}
12245
12246pub trait BusServerHandler<
12250 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12251 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12252>
12253{
12254 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12255 fn get_host_bridge_info(
12256 &mut self,
12257
12258 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12259 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12260
12261 #[doc = " Retrieve all Devices on the Bus.\n"]
12262 fn get_devices(
12263 &mut self,
12264
12265 responder: ::fidl_next::Responder<bus::GetDevices, ___T>,
12266 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12267
12268 #[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"]
12269 fn read_bar(
12270 &mut self,
12271
12272 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12273
12274 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12275 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12276}
12277
12278impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Bus
12279where
12280 ___H: BusServerHandler<___T> + ::core::marker::Send,
12281 ___T: ::fidl_next::Transport,
12282 for<'de> crate::wire::BusReadBarRequest: ::fidl_next::Decode<
12283 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12284 Constraint = (),
12285 >,
12286{
12287 async fn on_one_way(
12288 handler: &mut ___H,
12289 mut message: ::fidl_next::Message<___T>,
12290 ) -> ::core::result::Result<
12291 (),
12292 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12293 > {
12294 match *message.header().ordinal {
12295 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12296 }
12297 }
12298
12299 async fn on_two_way(
12300 handler: &mut ___H,
12301 mut message: ::fidl_next::Message<___T>,
12302 responder: ::fidl_next::protocol::Responder<___T>,
12303 ) -> ::core::result::Result<
12304 (),
12305 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12306 > {
12307 match *message.header().ordinal {
12308 4175032687054816861 => {
12309 let responder = ::fidl_next::Responder::from_untyped(responder);
12310
12311 handler.get_host_bridge_info(responder).await;
12312 Ok(())
12313 }
12314
12315 3114700014429961362 => {
12316 let responder = ::fidl_next::Responder::from_untyped(responder);
12317
12318 handler.get_devices(responder).await;
12319 Ok(())
12320 }
12321
12322 8759283232091687008 => {
12323 let responder = ::fidl_next::Responder::from_untyped(responder);
12324
12325 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12326 Ok(decoded) => {
12327 handler
12328 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12329 .await;
12330 Ok(())
12331 }
12332 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12333 ordinal: 8759283232091687008,
12334 error,
12335 }),
12336 }
12337 }
12338
12339 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12340 }
12341 }
12342}
12343
12344impl<___T> BusClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
12345
12346impl<___H, ___T> BusLocalClientHandler<___T> for ::fidl_next::Local<___H>
12347where
12348 ___H: BusClientHandler<___T>,
12349 ___T: ::fidl_next::Transport,
12350{
12351}
12352
12353impl<___H, ___T> BusLocalServerHandler<___T> for ::fidl_next::Local<___H>
12354where
12355 ___H: BusServerHandler<___T>,
12356 ___T: ::fidl_next::Transport,
12357{
12358 async fn get_host_bridge_info(
12359 &mut self,
12360
12361 responder: ::fidl_next::Responder<bus::GetHostBridgeInfo, ___T>,
12362 ) {
12363 ___H::get_host_bridge_info(&mut self.0, responder).await
12364 }
12365
12366 async fn get_devices(&mut self, responder: ::fidl_next::Responder<bus::GetDevices, ___T>) {
12367 ___H::get_devices(&mut self.0, responder).await
12368 }
12369
12370 async fn read_bar(
12371 &mut self,
12372
12373 request: ::fidl_next::Request<bus::ReadBar, ___T>,
12374
12375 responder: ::fidl_next::Responder<bus::ReadBar, ___T>,
12376 ) {
12377 ___H::read_bar(&mut self.0, request, responder).await
12378 }
12379}
12380
12381pub const EXTENDED_CONFIG_SIZE: u32 = 4096 as u32;
12382
12383pub const MAX_BAR_COUNT: u8 = 6 as u8;
12384
12385pub const READBAR_MAX_SIZE: u32 = 1024 as u32;
12386
12387pub const STATUS_DEVSEL_MASK: crate::natural::Status =
12388 crate::natural::Status::from_bits_retain(1536);