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 #[doc = " Bus/device/function address used by the PCI root protocols.\n"]
398 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
399 #[repr(C)]
400 pub struct Bdf {
401 pub bus_id: u8,
402
403 pub device_id: u8,
404
405 pub function_id: u8,
406 }
407
408 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Bdf, ___E> for Bdf
409 where
410 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
411 {
412 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Bdf> = unsafe {
413 ::fidl_next::CopyOptimization::enable_if(
414 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
415 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
416 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
417 )
418 };
419
420 #[inline]
421 fn encode(
422 self,
423 encoder_: &mut ___E,
424 out_: &mut ::core::mem::MaybeUninit<crate::wire::Bdf>,
425 _: (),
426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
427 ::fidl_next::munge! {
428 let crate::wire::Bdf {
429 bus_id,
430 device_id,
431 function_id,
432
433 } = out_;
434 }
435
436 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
437
438 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
439
440 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
441
442 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
443
444 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
445
446 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
447
448 Ok(())
449 }
450 }
451
452 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Bdf, ___E> for &'a Bdf
453 where
454 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
455 {
456 #[inline]
457 fn encode(
458 self,
459 encoder_: &mut ___E,
460 out_: &mut ::core::mem::MaybeUninit<crate::wire::Bdf>,
461 _: (),
462 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
463 ::fidl_next::munge! {
464 let crate::wire::Bdf {
465 bus_id,
466 device_id,
467 function_id,
468
469 } = out_;
470 }
471
472 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
473
474 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
475
476 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
477
478 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
479
480 ::fidl_next::Encode::encode(&self.function_id, encoder_, function_id, ())?;
481
482 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
483
484 Ok(())
485 }
486 }
487
488 unsafe impl<___E>
489 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Bdf>, ___E> for Bdf
490 where
491 ___E: ::fidl_next::Encoder + ?Sized,
492 Bdf: ::fidl_next::Encode<crate::wire::Bdf, ___E>,
493 {
494 #[inline]
495 fn encode_option(
496 this: ::core::option::Option<Self>,
497 encoder: &mut ___E,
498 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Bdf>>,
499 _: (),
500 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
501 if let Some(inner) = this {
502 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
503 ::fidl_next::wire::Box::encode_present(out);
504 } else {
505 ::fidl_next::wire::Box::encode_absent(out);
506 }
507
508 Ok(())
509 }
510 }
511
512 unsafe impl<'a, ___E>
513 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Bdf>, ___E>
514 for &'a Bdf
515 where
516 ___E: ::fidl_next::Encoder + ?Sized,
517 &'a Bdf: ::fidl_next::Encode<crate::wire::Bdf, ___E>,
518 {
519 #[inline]
520 fn encode_option(
521 this: ::core::option::Option<Self>,
522 encoder: &mut ___E,
523 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Bdf>>,
524 _: (),
525 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
526 if let Some(inner) = this {
527 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
528 ::fidl_next::wire::Box::encode_present(out);
529 } else {
530 ::fidl_next::wire::Box::encode_absent(out);
531 }
532
533 Ok(())
534 }
535 }
536
537 impl ::fidl_next::FromWire<crate::wire::Bdf> for Bdf {
538 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Bdf, Self> = unsafe {
539 ::fidl_next::CopyOptimization::enable_if(
540 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
541 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
542 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
543 )
544 };
545
546 #[inline]
547 fn from_wire(wire: crate::wire::Bdf) -> Self {
548 Self {
549 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
550
551 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
552
553 function_id: ::fidl_next::FromWire::from_wire(wire.function_id),
554 }
555 }
556 }
557
558 impl ::fidl_next::FromWireRef<crate::wire::Bdf> for Bdf {
559 #[inline]
560 fn from_wire_ref(wire: &crate::wire::Bdf) -> Self {
561 Self {
562 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
563
564 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
565
566 function_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.function_id),
567 }
568 }
569 }
570
571 pub type UseIntxWorkaroundType = ();
572
573 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
574 pub struct BoardConfiguration {
575 pub use_intx_workaround: ::core::option::Option<crate::natural::UseIntxWorkaroundType>,
576
577 pub devicetree_bdfs: ::core::option::Option<::std::vec::Vec<crate::natural::Address>>,
578 }
579
580 impl BoardConfiguration {
581 fn __max_ordinal(&self) -> usize {
582 if self.devicetree_bdfs.is_some() {
583 return 2;
584 }
585
586 if self.use_intx_workaround.is_some() {
587 return 1;
588 }
589
590 0
591 }
592 }
593
594 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
595 for BoardConfiguration
596 where
597 ___E: ::fidl_next::Encoder + ?Sized,
598 {
599 #[inline]
600 fn encode(
601 mut self,
602 encoder: &mut ___E,
603 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
604 _: (),
605 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
606 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
607
608 let max_ord = self.__max_ordinal();
609
610 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
611 ::fidl_next::Wire::zero_padding(&mut out);
612
613 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
614 ::fidl_next::wire::Envelope,
615 >(encoder, max_ord);
616
617 for i in 1..=max_ord {
618 match i {
619 2 => {
620 if let Some(value) = self.devicetree_bdfs.take() {
621 ::fidl_next::wire::Envelope::encode_value::<
622 ::fidl_next::wire::Vector<'static, crate::wire::Address>,
623 ___E,
624 >(
625 value, preallocated.encoder, &mut out, (4294967295, ())
626 )?;
627 } else {
628 ::fidl_next::wire::Envelope::encode_zero(&mut out)
629 }
630 }
631
632 1 => {
633 if let Some(value) = self.use_intx_workaround.take() {
634 ::fidl_next::wire::Envelope::encode_value::<
635 crate::wire::UseIntxWorkaroundType,
636 ___E,
637 >(
638 value, preallocated.encoder, &mut out, ()
639 )?;
640 } else {
641 ::fidl_next::wire::Envelope::encode_zero(&mut out)
642 }
643 }
644
645 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
646 }
647 unsafe {
648 preallocated.write_next(out.assume_init_ref());
649 }
650 }
651
652 ::fidl_next::wire::Table::encode_len(table, max_ord);
653
654 Ok(())
655 }
656 }
657
658 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BoardConfiguration<'static>, ___E>
659 for &'a BoardConfiguration
660 where
661 ___E: ::fidl_next::Encoder + ?Sized,
662 {
663 #[inline]
664 fn encode(
665 self,
666 encoder: &mut ___E,
667 out: &mut ::core::mem::MaybeUninit<crate::wire::BoardConfiguration<'static>>,
668 _: (),
669 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
670 ::fidl_next::munge!(let crate::wire::BoardConfiguration { table } = out);
671
672 let max_ord = self.__max_ordinal();
673
674 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
675 ::fidl_next::Wire::zero_padding(&mut out);
676
677 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
678 ::fidl_next::wire::Envelope,
679 >(encoder, max_ord);
680
681 for i in 1..=max_ord {
682 match i {
683 2 => {
684 if let Some(value) = &self.devicetree_bdfs {
685 ::fidl_next::wire::Envelope::encode_value::<
686 ::fidl_next::wire::Vector<'static, crate::wire::Address>,
687 ___E,
688 >(
689 value, preallocated.encoder, &mut out, (4294967295, ())
690 )?;
691 } else {
692 ::fidl_next::wire::Envelope::encode_zero(&mut out)
693 }
694 }
695
696 1 => {
697 if let Some(value) = &self.use_intx_workaround {
698 ::fidl_next::wire::Envelope::encode_value::<
699 crate::wire::UseIntxWorkaroundType,
700 ___E,
701 >(
702 value, preallocated.encoder, &mut out, ()
703 )?;
704 } else {
705 ::fidl_next::wire::Envelope::encode_zero(&mut out)
706 }
707 }
708
709 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
710 }
711 unsafe {
712 preallocated.write_next(out.assume_init_ref());
713 }
714 }
715
716 ::fidl_next::wire::Table::encode_len(table, max_ord);
717
718 Ok(())
719 }
720 }
721
722 impl<'de> ::fidl_next::FromWire<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
723 #[inline]
724 fn from_wire(wire_: crate::wire::BoardConfiguration<'de>) -> Self {
725 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
726
727 let use_intx_workaround = wire_.table.get(1);
728
729 let devicetree_bdfs = wire_.table.get(2);
730
731 Self {
732 use_intx_workaround: use_intx_workaround.map(|envelope| {
733 ::fidl_next::FromWire::from_wire(unsafe {
734 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
735 })
736 }),
737
738 devicetree_bdfs: devicetree_bdfs.map(|envelope| {
739 ::fidl_next::FromWire::from_wire(unsafe {
740 envelope
741 .read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>(
742 )
743 })
744 }),
745 }
746 }
747 }
748
749 impl<'de> ::fidl_next::FromWireRef<crate::wire::BoardConfiguration<'de>> for BoardConfiguration {
750 #[inline]
751 fn from_wire_ref(wire: &crate::wire::BoardConfiguration<'de>) -> Self {
752 Self {
753
754
755 use_intx_workaround: wire.table.get(1)
756 .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
757 unsafe { envelope.deref_unchecked::<crate::wire::UseIntxWorkaroundType>() }
758 )),
759
760
761 devicetree_bdfs: wire.table.get(2)
762 .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
763 unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>() }
764 )),
765
766 }
767 }
768 }
769
770 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
771 #[repr(C)]
772 pub struct Capability {
773 pub id: u8,
774
775 pub offset: u8,
776 }
777
778 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability
779 where
780 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
781 {
782 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Capability> = unsafe {
783 ::fidl_next::CopyOptimization::enable_if(
784 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
785 && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
786 )
787 };
788
789 #[inline]
790 fn encode(
791 self,
792 encoder_: &mut ___E,
793 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
794 _: (),
795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
796 ::fidl_next::munge! {
797 let crate::wire::Capability {
798 id,
799 offset,
800
801 } = out_;
802 }
803
804 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
805
806 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
807
808 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
809
810 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
811
812 Ok(())
813 }
814 }
815
816 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Capability, ___E> for &'a Capability
817 where
818 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
819 {
820 #[inline]
821 fn encode(
822 self,
823 encoder_: &mut ___E,
824 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
825 _: (),
826 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
827 ::fidl_next::munge! {
828 let crate::wire::Capability {
829 id,
830 offset,
831
832 } = out_;
833 }
834
835 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
836
837 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
838
839 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
840
841 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
842
843 Ok(())
844 }
845 }
846
847 unsafe impl<___E>
848 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
849 for Capability
850 where
851 ___E: ::fidl_next::Encoder + ?Sized,
852 Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
853 {
854 #[inline]
855 fn encode_option(
856 this: ::core::option::Option<Self>,
857 encoder: &mut ___E,
858 out: &mut ::core::mem::MaybeUninit<
859 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
860 >,
861 _: (),
862 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
863 if let Some(inner) = this {
864 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
865 ::fidl_next::wire::Box::encode_present(out);
866 } else {
867 ::fidl_next::wire::Box::encode_absent(out);
868 }
869
870 Ok(())
871 }
872 }
873
874 unsafe impl<'a, ___E>
875 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Capability>, ___E>
876 for &'a Capability
877 where
878 ___E: ::fidl_next::Encoder + ?Sized,
879 &'a Capability: ::fidl_next::Encode<crate::wire::Capability, ___E>,
880 {
881 #[inline]
882 fn encode_option(
883 this: ::core::option::Option<Self>,
884 encoder: &mut ___E,
885 out: &mut ::core::mem::MaybeUninit<
886 ::fidl_next::wire::Box<'static, crate::wire::Capability>,
887 >,
888 _: (),
889 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
890 if let Some(inner) = this {
891 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
892 ::fidl_next::wire::Box::encode_present(out);
893 } else {
894 ::fidl_next::wire::Box::encode_absent(out);
895 }
896
897 Ok(())
898 }
899 }
900
901 impl ::fidl_next::FromWire<crate::wire::Capability> for Capability {
902 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Capability, Self> = unsafe {
903 ::fidl_next::CopyOptimization::enable_if(
904 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
905 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
906 )
907 };
908
909 #[inline]
910 fn from_wire(wire: crate::wire::Capability) -> Self {
911 Self {
912 id: ::fidl_next::FromWire::from_wire(wire.id),
913
914 offset: ::fidl_next::FromWire::from_wire(wire.offset),
915 }
916 }
917 }
918
919 impl ::fidl_next::FromWireRef<crate::wire::Capability> for Capability {
920 #[inline]
921 fn from_wire_ref(wire: &crate::wire::Capability) -> Self {
922 Self {
923 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
924
925 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
926 }
927 }
928 }
929
930 #[doc = " PCI Capability ID.\n PCI Local Bus Specification v3, appendex H.\n"]
931 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
932 #[repr(u8)]
933 pub enum CapabilityId {
934 Null = 0,
935 PciPwrMgmt = 1,
936 Agp = 2,
937 VitalProductData = 3,
938 SlotIdentification = 4,
939 Msi = 5,
940 CompactPciHotswap = 6,
941 Pcix = 7,
942 Hypertransport = 8,
943 Vendor = 9,
944 DebugPort = 10,
945 CompactPciCrc = 11,
946 PciHotPlug = 12,
947 PciBridgeSubsystemVid = 13,
948 Agp8X = 14,
949 SecureDevice = 15,
950 PciExpress = 16,
951 Msix = 17,
952 SataDataNdxCfg = 18,
953 AdvancedFeatures = 19,
954 EnhancedAllocation = 20,
955 FlatteningPortalBridge = 21,
956 UnknownOrdinal_(u8) = 22,
957 }
958 impl ::std::convert::From<u8> for CapabilityId {
959 fn from(value: u8) -> Self {
960 match value {
961 0 => Self::Null,
962 1 => Self::PciPwrMgmt,
963 2 => Self::Agp,
964 3 => Self::VitalProductData,
965 4 => Self::SlotIdentification,
966 5 => Self::Msi,
967 6 => Self::CompactPciHotswap,
968 7 => Self::Pcix,
969 8 => Self::Hypertransport,
970 9 => Self::Vendor,
971 10 => Self::DebugPort,
972 11 => Self::CompactPciCrc,
973 12 => Self::PciHotPlug,
974 13 => Self::PciBridgeSubsystemVid,
975 14 => Self::Agp8X,
976 15 => Self::SecureDevice,
977 16 => Self::PciExpress,
978 17 => Self::Msix,
979 18 => Self::SataDataNdxCfg,
980 19 => Self::AdvancedFeatures,
981 20 => Self::EnhancedAllocation,
982 21 => Self::FlatteningPortalBridge,
983
984 _ => Self::UnknownOrdinal_(value),
985 }
986 }
987 }
988
989 impl ::std::convert::From<CapabilityId> for u8 {
990 fn from(value: CapabilityId) -> Self {
991 match value {
992 CapabilityId::Null => 0,
993 CapabilityId::PciPwrMgmt => 1,
994 CapabilityId::Agp => 2,
995 CapabilityId::VitalProductData => 3,
996 CapabilityId::SlotIdentification => 4,
997 CapabilityId::Msi => 5,
998 CapabilityId::CompactPciHotswap => 6,
999 CapabilityId::Pcix => 7,
1000 CapabilityId::Hypertransport => 8,
1001 CapabilityId::Vendor => 9,
1002 CapabilityId::DebugPort => 10,
1003 CapabilityId::CompactPciCrc => 11,
1004 CapabilityId::PciHotPlug => 12,
1005 CapabilityId::PciBridgeSubsystemVid => 13,
1006 CapabilityId::Agp8X => 14,
1007 CapabilityId::SecureDevice => 15,
1008 CapabilityId::PciExpress => 16,
1009 CapabilityId::Msix => 17,
1010 CapabilityId::SataDataNdxCfg => 18,
1011 CapabilityId::AdvancedFeatures => 19,
1012 CapabilityId::EnhancedAllocation => 20,
1013 CapabilityId::FlatteningPortalBridge => 21,
1014
1015 CapabilityId::UnknownOrdinal_(value) => value,
1016 }
1017 }
1018 }
1019
1020 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for CapabilityId
1021 where
1022 ___E: ?Sized,
1023 {
1024 #[inline]
1025 fn encode(
1026 self,
1027 encoder: &mut ___E,
1028 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
1029 _: (),
1030 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1031 ::fidl_next::Encode::encode(&self, encoder, out, ())
1032 }
1033 }
1034
1035 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityId, ___E> for &'a CapabilityId
1036 where
1037 ___E: ?Sized,
1038 {
1039 #[inline]
1040 fn encode(
1041 self,
1042 encoder: &mut ___E,
1043 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityId>,
1044 _: (),
1045 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1046 ::fidl_next::munge!(let crate::wire::CapabilityId { value } = out);
1047 let _ = value.write(u8::from(match *self {
1048 CapabilityId::Null => 0,
1049
1050 CapabilityId::PciPwrMgmt => 1,
1051
1052 CapabilityId::Agp => 2,
1053
1054 CapabilityId::VitalProductData => 3,
1055
1056 CapabilityId::SlotIdentification => 4,
1057
1058 CapabilityId::Msi => 5,
1059
1060 CapabilityId::CompactPciHotswap => 6,
1061
1062 CapabilityId::Pcix => 7,
1063
1064 CapabilityId::Hypertransport => 8,
1065
1066 CapabilityId::Vendor => 9,
1067
1068 CapabilityId::DebugPort => 10,
1069
1070 CapabilityId::CompactPciCrc => 11,
1071
1072 CapabilityId::PciHotPlug => 12,
1073
1074 CapabilityId::PciBridgeSubsystemVid => 13,
1075
1076 CapabilityId::Agp8X => 14,
1077
1078 CapabilityId::SecureDevice => 15,
1079
1080 CapabilityId::PciExpress => 16,
1081
1082 CapabilityId::Msix => 17,
1083
1084 CapabilityId::SataDataNdxCfg => 18,
1085
1086 CapabilityId::AdvancedFeatures => 19,
1087
1088 CapabilityId::EnhancedAllocation => 20,
1089
1090 CapabilityId::FlatteningPortalBridge => 21,
1091
1092 CapabilityId::UnknownOrdinal_(value) => value,
1093 }));
1094
1095 Ok(())
1096 }
1097 }
1098
1099 impl ::core::convert::From<crate::wire::CapabilityId> for CapabilityId {
1100 fn from(wire: crate::wire::CapabilityId) -> Self {
1101 match u8::from(wire.value) {
1102 0 => Self::Null,
1103
1104 1 => Self::PciPwrMgmt,
1105
1106 2 => Self::Agp,
1107
1108 3 => Self::VitalProductData,
1109
1110 4 => Self::SlotIdentification,
1111
1112 5 => Self::Msi,
1113
1114 6 => Self::CompactPciHotswap,
1115
1116 7 => Self::Pcix,
1117
1118 8 => Self::Hypertransport,
1119
1120 9 => Self::Vendor,
1121
1122 10 => Self::DebugPort,
1123
1124 11 => Self::CompactPciCrc,
1125
1126 12 => Self::PciHotPlug,
1127
1128 13 => Self::PciBridgeSubsystemVid,
1129
1130 14 => Self::Agp8X,
1131
1132 15 => Self::SecureDevice,
1133
1134 16 => Self::PciExpress,
1135
1136 17 => Self::Msix,
1137
1138 18 => Self::SataDataNdxCfg,
1139
1140 19 => Self::AdvancedFeatures,
1141
1142 20 => Self::EnhancedAllocation,
1143
1144 21 => Self::FlatteningPortalBridge,
1145
1146 value => Self::UnknownOrdinal_(value),
1147 }
1148 }
1149 }
1150
1151 impl ::fidl_next::FromWire<crate::wire::CapabilityId> for CapabilityId {
1152 #[inline]
1153 fn from_wire(wire: crate::wire::CapabilityId) -> Self {
1154 Self::from(wire)
1155 }
1156 }
1157
1158 impl ::fidl_next::FromWireRef<crate::wire::CapabilityId> for CapabilityId {
1159 #[inline]
1160 fn from_wire_ref(wire: &crate::wire::CapabilityId) -> Self {
1161 Self::from(*wire)
1162 }
1163 }
1164
1165 ::fidl_next::bitflags::bitflags! {
1166 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Command: u16 {
1167 const IO_EN = 1;
1168 const MEM_EN = 2;
1169 const BUS_MASTER_EN = 4;
1170 const SPECIAL_EN = 8;
1171 const MEM_WR_INV_EN = 16;
1172 const PAL_SNOOP_EN = 32;
1173 const PERR_RESP_EN = 64;
1174 const AD_STEP_EN = 128;
1175 const SERR_EN = 256;
1176 const FAST_B2_B_EN = 512;
1177 const _ = !0;
1178 }
1179 }
1180
1181 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Command, ___E> for Command
1182 where
1183 ___E: ?Sized,
1184 {
1185 #[inline]
1186 fn encode(
1187 self,
1188 encoder: &mut ___E,
1189 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
1190 _: (),
1191 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1192 ::fidl_next::Encode::encode(&self, encoder, out, ())
1193 }
1194 }
1195
1196 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Command, ___E> for &'a Command
1197 where
1198 ___E: ?Sized,
1199 {
1200 #[inline]
1201 fn encode(
1202 self,
1203 _: &mut ___E,
1204 out: &mut ::core::mem::MaybeUninit<crate::wire::Command>,
1205 _: (),
1206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1207 ::fidl_next::munge!(let crate::wire::Command { value } = out);
1208
1209 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
1210 Ok(())
1211 }
1212 }
1213
1214 impl ::core::convert::From<crate::wire::Command> for Command {
1215 fn from(wire: crate::wire::Command) -> Self {
1216 Self::from_bits_retain(u16::from(wire.value))
1217 }
1218 }
1219
1220 impl ::fidl_next::FromWire<crate::wire::Command> for Command {
1221 #[inline]
1222 fn from_wire(wire: crate::wire::Command) -> Self {
1223 Self::from(wire)
1224 }
1225 }
1226
1227 impl ::fidl_next::FromWireRef<crate::wire::Command> for Command {
1228 #[inline]
1229 fn from_wire_ref(wire: &crate::wire::Command) -> Self {
1230 Self::from(*wire)
1231 }
1232 }
1233
1234 #[doc = " PCI Configuration Header registers.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
1235 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1236 #[repr(u16)]
1237 pub enum Config {
1238 VendorId = 0,
1239 DeviceId = 2,
1240 Command = 4,
1241 Status = 6,
1242 RevisionId = 8,
1243 ClassCodeIntr = 9,
1244 ClassCodeSub = 10,
1245 ClassCodeBase = 11,
1246 CacheLineSize = 12,
1247 LatencyTimer = 13,
1248 HeaderType = 14,
1249 Bist = 15,
1250 BaseAddresses = 16,
1251 CardbusCisPtr = 40,
1252 SubsystemVendorId = 44,
1253 SubsystemId = 46,
1254 ExpRomAddress = 48,
1255 CapabilitiesPtr = 52,
1256 InterruptLine = 60,
1257 InterruptPin = 61,
1258 MinGrant = 62,
1259 MaxLatency = 63,
1260 UnknownOrdinal_(u16) = 64,
1261 }
1262 impl ::std::convert::From<u16> for Config {
1263 fn from(value: u16) -> Self {
1264 match value {
1265 0 => Self::VendorId,
1266 2 => Self::DeviceId,
1267 4 => Self::Command,
1268 6 => Self::Status,
1269 8 => Self::RevisionId,
1270 9 => Self::ClassCodeIntr,
1271 10 => Self::ClassCodeSub,
1272 11 => Self::ClassCodeBase,
1273 12 => Self::CacheLineSize,
1274 13 => Self::LatencyTimer,
1275 14 => Self::HeaderType,
1276 15 => Self::Bist,
1277 16 => Self::BaseAddresses,
1278 40 => Self::CardbusCisPtr,
1279 44 => Self::SubsystemVendorId,
1280 46 => Self::SubsystemId,
1281 48 => Self::ExpRomAddress,
1282 52 => Self::CapabilitiesPtr,
1283 60 => Self::InterruptLine,
1284 61 => Self::InterruptPin,
1285 62 => Self::MinGrant,
1286 63 => Self::MaxLatency,
1287
1288 _ => Self::UnknownOrdinal_(value),
1289 }
1290 }
1291 }
1292
1293 impl ::std::convert::From<Config> for u16 {
1294 fn from(value: Config) -> Self {
1295 match value {
1296 Config::VendorId => 0,
1297 Config::DeviceId => 2,
1298 Config::Command => 4,
1299 Config::Status => 6,
1300 Config::RevisionId => 8,
1301 Config::ClassCodeIntr => 9,
1302 Config::ClassCodeSub => 10,
1303 Config::ClassCodeBase => 11,
1304 Config::CacheLineSize => 12,
1305 Config::LatencyTimer => 13,
1306 Config::HeaderType => 14,
1307 Config::Bist => 15,
1308 Config::BaseAddresses => 16,
1309 Config::CardbusCisPtr => 40,
1310 Config::SubsystemVendorId => 44,
1311 Config::SubsystemId => 46,
1312 Config::ExpRomAddress => 48,
1313 Config::CapabilitiesPtr => 52,
1314 Config::InterruptLine => 60,
1315 Config::InterruptPin => 61,
1316 Config::MinGrant => 62,
1317 Config::MaxLatency => 63,
1318
1319 Config::UnknownOrdinal_(value) => value,
1320 }
1321 }
1322 }
1323
1324 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Config, ___E> for Config
1325 where
1326 ___E: ?Sized,
1327 {
1328 #[inline]
1329 fn encode(
1330 self,
1331 encoder: &mut ___E,
1332 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
1333 _: (),
1334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1335 ::fidl_next::Encode::encode(&self, encoder, out, ())
1336 }
1337 }
1338
1339 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Config, ___E> for &'a Config
1340 where
1341 ___E: ?Sized,
1342 {
1343 #[inline]
1344 fn encode(
1345 self,
1346 encoder: &mut ___E,
1347 out: &mut ::core::mem::MaybeUninit<crate::wire::Config>,
1348 _: (),
1349 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1350 ::fidl_next::munge!(let crate::wire::Config { value } = out);
1351 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
1352 Config::VendorId => 0,
1353
1354 Config::DeviceId => 2,
1355
1356 Config::Command => 4,
1357
1358 Config::Status => 6,
1359
1360 Config::RevisionId => 8,
1361
1362 Config::ClassCodeIntr => 9,
1363
1364 Config::ClassCodeSub => 10,
1365
1366 Config::ClassCodeBase => 11,
1367
1368 Config::CacheLineSize => 12,
1369
1370 Config::LatencyTimer => 13,
1371
1372 Config::HeaderType => 14,
1373
1374 Config::Bist => 15,
1375
1376 Config::BaseAddresses => 16,
1377
1378 Config::CardbusCisPtr => 40,
1379
1380 Config::SubsystemVendorId => 44,
1381
1382 Config::SubsystemId => 46,
1383
1384 Config::ExpRomAddress => 48,
1385
1386 Config::CapabilitiesPtr => 52,
1387
1388 Config::InterruptLine => 60,
1389
1390 Config::InterruptPin => 61,
1391
1392 Config::MinGrant => 62,
1393
1394 Config::MaxLatency => 63,
1395
1396 Config::UnknownOrdinal_(value) => value,
1397 }));
1398
1399 Ok(())
1400 }
1401 }
1402
1403 impl ::core::convert::From<crate::wire::Config> for Config {
1404 fn from(wire: crate::wire::Config) -> Self {
1405 match u16::from(wire.value) {
1406 0 => Self::VendorId,
1407
1408 2 => Self::DeviceId,
1409
1410 4 => Self::Command,
1411
1412 6 => Self::Status,
1413
1414 8 => Self::RevisionId,
1415
1416 9 => Self::ClassCodeIntr,
1417
1418 10 => Self::ClassCodeSub,
1419
1420 11 => Self::ClassCodeBase,
1421
1422 12 => Self::CacheLineSize,
1423
1424 13 => Self::LatencyTimer,
1425
1426 14 => Self::HeaderType,
1427
1428 15 => Self::Bist,
1429
1430 16 => Self::BaseAddresses,
1431
1432 40 => Self::CardbusCisPtr,
1433
1434 44 => Self::SubsystemVendorId,
1435
1436 46 => Self::SubsystemId,
1437
1438 48 => Self::ExpRomAddress,
1439
1440 52 => Self::CapabilitiesPtr,
1441
1442 60 => Self::InterruptLine,
1443
1444 61 => Self::InterruptPin,
1445
1446 62 => Self::MinGrant,
1447
1448 63 => Self::MaxLatency,
1449
1450 value => Self::UnknownOrdinal_(value),
1451 }
1452 }
1453 }
1454
1455 impl ::fidl_next::FromWire<crate::wire::Config> for Config {
1456 #[inline]
1457 fn from_wire(wire: crate::wire::Config) -> Self {
1458 Self::from(wire)
1459 }
1460 }
1461
1462 impl ::fidl_next::FromWireRef<crate::wire::Config> for Config {
1463 #[inline]
1464 fn from_wire_ref(wire: &crate::wire::Config) -> Self {
1465 Self::from(*wire)
1466 }
1467 }
1468
1469 #[doc = " An offset from the beginning of a device\'s PCI configuration space. [0, 0x100) is valid.\n"]
1470 pub type ConfigOffset = u8;
1471
1472 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1473 pub struct HostBridgeInfo {
1474 pub name: ::std::string::String,
1475
1476 pub start_bus_number: u8,
1477
1478 pub end_bus_number: u8,
1479
1480 pub segment_group: u16,
1481 }
1482
1483 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E> for HostBridgeInfo
1484 where
1485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1486 ___E: ::fidl_next::Encoder,
1487 {
1488 #[inline]
1489 fn encode(
1490 self,
1491 encoder_: &mut ___E,
1492 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
1493 _: (),
1494 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1495 ::fidl_next::munge! {
1496 let crate::wire::HostBridgeInfo {
1497 name,
1498 start_bus_number,
1499 end_bus_number,
1500 segment_group,
1501
1502 } = out_;
1503 }
1504
1505 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
1506
1507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1508 ::fidl_next::Constrained::validate(_field, 32)?;
1509
1510 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
1511
1512 let mut _field =
1513 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
1514
1515 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
1516
1517 let mut _field =
1518 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
1519
1520 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
1521
1522 let mut _field =
1523 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
1524
1525 Ok(())
1526 }
1527 }
1528
1529 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
1530 for &'a HostBridgeInfo
1531 where
1532 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1533 ___E: ::fidl_next::Encoder,
1534 {
1535 #[inline]
1536 fn encode(
1537 self,
1538 encoder_: &mut ___E,
1539 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
1540 _: (),
1541 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1542 ::fidl_next::munge! {
1543 let crate::wire::HostBridgeInfo {
1544 name,
1545 start_bus_number,
1546 end_bus_number,
1547 segment_group,
1548
1549 } = out_;
1550 }
1551
1552 ::fidl_next::Encode::encode(&self.name, encoder_, name, 32)?;
1553
1554 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1555 ::fidl_next::Constrained::validate(_field, 32)?;
1556
1557 ::fidl_next::Encode::encode(&self.start_bus_number, encoder_, start_bus_number, ())?;
1558
1559 let mut _field =
1560 unsafe { ::fidl_next::Slot::new_unchecked(start_bus_number.as_mut_ptr()) };
1561
1562 ::fidl_next::Encode::encode(&self.end_bus_number, encoder_, end_bus_number, ())?;
1563
1564 let mut _field =
1565 unsafe { ::fidl_next::Slot::new_unchecked(end_bus_number.as_mut_ptr()) };
1566
1567 ::fidl_next::Encode::encode(&self.segment_group, encoder_, segment_group, ())?;
1568
1569 let mut _field =
1570 unsafe { ::fidl_next::Slot::new_unchecked(segment_group.as_mut_ptr()) };
1571
1572 Ok(())
1573 }
1574 }
1575
1576 unsafe impl<___E>
1577 ::fidl_next::EncodeOption<
1578 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
1579 ___E,
1580 > for HostBridgeInfo
1581 where
1582 ___E: ::fidl_next::Encoder + ?Sized,
1583 HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
1584 {
1585 #[inline]
1586 fn encode_option(
1587 this: ::core::option::Option<Self>,
1588 encoder: &mut ___E,
1589 out: &mut ::core::mem::MaybeUninit<
1590 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
1591 >,
1592 _: (),
1593 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1594 if let Some(inner) = this {
1595 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1596 ::fidl_next::wire::Box::encode_present(out);
1597 } else {
1598 ::fidl_next::wire::Box::encode_absent(out);
1599 }
1600
1601 Ok(())
1602 }
1603 }
1604
1605 unsafe impl<'a, ___E>
1606 ::fidl_next::EncodeOption<
1607 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
1608 ___E,
1609 > for &'a HostBridgeInfo
1610 where
1611 ___E: ::fidl_next::Encoder + ?Sized,
1612 &'a HostBridgeInfo: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
1613 {
1614 #[inline]
1615 fn encode_option(
1616 this: ::core::option::Option<Self>,
1617 encoder: &mut ___E,
1618 out: &mut ::core::mem::MaybeUninit<
1619 ::fidl_next::wire::Box<'static, crate::wire::HostBridgeInfo<'static>>,
1620 >,
1621 _: (),
1622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1623 if let Some(inner) = this {
1624 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1625 ::fidl_next::wire::Box::encode_present(out);
1626 } else {
1627 ::fidl_next::wire::Box::encode_absent(out);
1628 }
1629
1630 Ok(())
1631 }
1632 }
1633
1634 impl<'de> ::fidl_next::FromWire<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
1635 #[inline]
1636 fn from_wire(wire: crate::wire::HostBridgeInfo<'de>) -> Self {
1637 Self {
1638 name: ::fidl_next::FromWire::from_wire(wire.name),
1639
1640 start_bus_number: ::fidl_next::FromWire::from_wire(wire.start_bus_number),
1641
1642 end_bus_number: ::fidl_next::FromWire::from_wire(wire.end_bus_number),
1643
1644 segment_group: ::fidl_next::FromWire::from_wire(wire.segment_group),
1645 }
1646 }
1647 }
1648
1649 impl<'de> ::fidl_next::FromWireRef<crate::wire::HostBridgeInfo<'de>> for HostBridgeInfo {
1650 #[inline]
1651 fn from_wire_ref(wire: &crate::wire::HostBridgeInfo<'de>) -> Self {
1652 Self {
1653 name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
1654
1655 start_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_bus_number),
1656
1657 end_bus_number: ::fidl_next::FromWireRef::from_wire_ref(&wire.end_bus_number),
1658
1659 segment_group: ::fidl_next::FromWireRef::from_wire_ref(&wire.segment_group),
1660 }
1661 }
1662 }
1663
1664 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1665 pub struct DebugGetHostBridgeInfoResponse {
1666 pub info: crate::natural::HostBridgeInfo,
1667 }
1668
1669 unsafe impl<___E>
1670 ::fidl_next::Encode<crate::wire::DebugGetHostBridgeInfoResponse<'static>, ___E>
1671 for DebugGetHostBridgeInfoResponse
1672 where
1673 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1674 ___E: ::fidl_next::Encoder,
1675 {
1676 #[inline]
1677 fn encode(
1678 self,
1679 encoder_: &mut ___E,
1680 out_: &mut ::core::mem::MaybeUninit<
1681 crate::wire::DebugGetHostBridgeInfoResponse<'static>,
1682 >,
1683 _: (),
1684 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1685 ::fidl_next::munge! {
1686 let crate::wire::DebugGetHostBridgeInfoResponse {
1687 info,
1688
1689 } = out_;
1690 }
1691
1692 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1693
1694 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1695
1696 Ok(())
1697 }
1698 }
1699
1700 unsafe impl<'a, ___E>
1701 ::fidl_next::Encode<crate::wire::DebugGetHostBridgeInfoResponse<'static>, ___E>
1702 for &'a DebugGetHostBridgeInfoResponse
1703 where
1704 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1705 ___E: ::fidl_next::Encoder,
1706 {
1707 #[inline]
1708 fn encode(
1709 self,
1710 encoder_: &mut ___E,
1711 out_: &mut ::core::mem::MaybeUninit<
1712 crate::wire::DebugGetHostBridgeInfoResponse<'static>,
1713 >,
1714 _: (),
1715 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1716 ::fidl_next::munge! {
1717 let crate::wire::DebugGetHostBridgeInfoResponse {
1718 info,
1719
1720 } = out_;
1721 }
1722
1723 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
1724
1725 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1726
1727 Ok(())
1728 }
1729 }
1730
1731 unsafe impl<___E>
1732 ::fidl_next::EncodeOption<
1733 ::fidl_next::wire::Box<'static, crate::wire::DebugGetHostBridgeInfoResponse<'static>>,
1734 ___E,
1735 > for DebugGetHostBridgeInfoResponse
1736 where
1737 ___E: ::fidl_next::Encoder + ?Sized,
1738 DebugGetHostBridgeInfoResponse:
1739 ::fidl_next::Encode<crate::wire::DebugGetHostBridgeInfoResponse<'static>, ___E>,
1740 {
1741 #[inline]
1742 fn encode_option(
1743 this: ::core::option::Option<Self>,
1744 encoder: &mut ___E,
1745 out: &mut ::core::mem::MaybeUninit<
1746 ::fidl_next::wire::Box<
1747 'static,
1748 crate::wire::DebugGetHostBridgeInfoResponse<'static>,
1749 >,
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 unsafe impl<'a, ___E>
1765 ::fidl_next::EncodeOption<
1766 ::fidl_next::wire::Box<'static, crate::wire::DebugGetHostBridgeInfoResponse<'static>>,
1767 ___E,
1768 > for &'a DebugGetHostBridgeInfoResponse
1769 where
1770 ___E: ::fidl_next::Encoder + ?Sized,
1771 &'a DebugGetHostBridgeInfoResponse:
1772 ::fidl_next::Encode<crate::wire::DebugGetHostBridgeInfoResponse<'static>, ___E>,
1773 {
1774 #[inline]
1775 fn encode_option(
1776 this: ::core::option::Option<Self>,
1777 encoder: &mut ___E,
1778 out: &mut ::core::mem::MaybeUninit<
1779 ::fidl_next::wire::Box<
1780 'static,
1781 crate::wire::DebugGetHostBridgeInfoResponse<'static>,
1782 >,
1783 >,
1784 _: (),
1785 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1786 if let Some(inner) = this {
1787 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1788 ::fidl_next::wire::Box::encode_present(out);
1789 } else {
1790 ::fidl_next::wire::Box::encode_absent(out);
1791 }
1792
1793 Ok(())
1794 }
1795 }
1796
1797 impl<'de> ::fidl_next::FromWire<crate::wire::DebugGetHostBridgeInfoResponse<'de>>
1798 for DebugGetHostBridgeInfoResponse
1799 {
1800 #[inline]
1801 fn from_wire(wire: crate::wire::DebugGetHostBridgeInfoResponse<'de>) -> Self {
1802 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
1803 }
1804 }
1805
1806 impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugGetHostBridgeInfoResponse<'de>>
1807 for DebugGetHostBridgeInfoResponse
1808 {
1809 #[inline]
1810 fn from_wire_ref(wire: &crate::wire::DebugGetHostBridgeInfoResponse<'de>) -> Self {
1811 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
1812 }
1813 }
1814
1815 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1816 #[repr(C)]
1817 pub struct ExtendedCapability {
1818 pub id: u16,
1819
1820 pub offset: u16,
1821 }
1822
1823 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E> for ExtendedCapability
1824 where
1825 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1826 {
1827 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1828 Self,
1829 crate::wire::ExtendedCapability,
1830 > = unsafe {
1831 ::fidl_next::CopyOptimization::enable_if(
1832 true
1833
1834 && <
1835 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1836 >::COPY_OPTIMIZATION.is_enabled()
1837
1838 && <
1839 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
1840 >::COPY_OPTIMIZATION.is_enabled()
1841
1842 )
1843 };
1844
1845 #[inline]
1846 fn encode(
1847 self,
1848 encoder_: &mut ___E,
1849 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1850 _: (),
1851 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1852 ::fidl_next::munge! {
1853 let crate::wire::ExtendedCapability {
1854 id,
1855 offset,
1856
1857 } = out_;
1858 }
1859
1860 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1861
1862 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1863
1864 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1865
1866 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1867
1868 Ok(())
1869 }
1870 }
1871
1872 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
1873 for &'a ExtendedCapability
1874 where
1875 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1876 {
1877 #[inline]
1878 fn encode(
1879 self,
1880 encoder_: &mut ___E,
1881 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
1882 _: (),
1883 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1884 ::fidl_next::munge! {
1885 let crate::wire::ExtendedCapability {
1886 id,
1887 offset,
1888
1889 } = out_;
1890 }
1891
1892 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1893
1894 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1895
1896 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
1897
1898 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1899
1900 Ok(())
1901 }
1902 }
1903
1904 unsafe impl<___E>
1905 ::fidl_next::EncodeOption<
1906 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1907 ___E,
1908 > for ExtendedCapability
1909 where
1910 ___E: ::fidl_next::Encoder + ?Sized,
1911 ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1912 {
1913 #[inline]
1914 fn encode_option(
1915 this: ::core::option::Option<Self>,
1916 encoder: &mut ___E,
1917 out: &mut ::core::mem::MaybeUninit<
1918 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1919 >,
1920 _: (),
1921 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1922 if let Some(inner) = this {
1923 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1924 ::fidl_next::wire::Box::encode_present(out);
1925 } else {
1926 ::fidl_next::wire::Box::encode_absent(out);
1927 }
1928
1929 Ok(())
1930 }
1931 }
1932
1933 unsafe impl<'a, ___E>
1934 ::fidl_next::EncodeOption<
1935 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1936 ___E,
1937 > for &'a ExtendedCapability
1938 where
1939 ___E: ::fidl_next::Encoder + ?Sized,
1940 &'a ExtendedCapability: ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>,
1941 {
1942 #[inline]
1943 fn encode_option(
1944 this: ::core::option::Option<Self>,
1945 encoder: &mut ___E,
1946 out: &mut ::core::mem::MaybeUninit<
1947 ::fidl_next::wire::Box<'static, crate::wire::ExtendedCapability>,
1948 >,
1949 _: (),
1950 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1951 if let Some(inner) = this {
1952 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1953 ::fidl_next::wire::Box::encode_present(out);
1954 } else {
1955 ::fidl_next::wire::Box::encode_absent(out);
1956 }
1957
1958 Ok(())
1959 }
1960 }
1961
1962 impl ::fidl_next::FromWire<crate::wire::ExtendedCapability> for ExtendedCapability {
1963 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1964 crate::wire::ExtendedCapability,
1965 Self,
1966 > = unsafe {
1967 ::fidl_next::CopyOptimization::enable_if(
1968 true
1969 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1970 .is_enabled()
1971 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
1972 .is_enabled(),
1973 )
1974 };
1975
1976 #[inline]
1977 fn from_wire(wire: crate::wire::ExtendedCapability) -> Self {
1978 Self {
1979 id: ::fidl_next::FromWire::from_wire(wire.id),
1980
1981 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1982 }
1983 }
1984 }
1985
1986 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapability> for ExtendedCapability {
1987 #[inline]
1988 fn from_wire_ref(wire: &crate::wire::ExtendedCapability) -> Self {
1989 Self {
1990 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1991
1992 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
1993 }
1994 }
1995 }
1996
1997 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1998 pub struct PciDevice {
1999 pub base_addresses: ::std::vec::Vec<crate::natural::BaseAddress>,
2000
2001 pub capabilities: ::std::vec::Vec<crate::natural::Capability>,
2002
2003 pub ext_capabilities: ::std::vec::Vec<crate::natural::ExtendedCapability>,
2004
2005 pub config: ::std::vec::Vec<u8>,
2006
2007 pub bus_id: u8,
2008
2009 pub device_id: u8,
2010
2011 pub function_id: u8,
2012 }
2013
2014 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for PciDevice
2015 where
2016 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2017 ___E: ::fidl_next::Encoder,
2018 {
2019 #[inline]
2020 fn encode(
2021 self,
2022 encoder_: &mut ___E,
2023 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
2024 _: (),
2025 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2026 ::fidl_next::munge! {
2027 let crate::wire::PciDevice {
2028 base_addresses,
2029 capabilities,
2030 ext_capabilities,
2031 config,
2032 bus_id,
2033 device_id,
2034 function_id,
2035
2036 } = out_;
2037 }
2038
2039 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
2040
2041 let mut _field =
2042 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
2043 ::fidl_next::Constrained::validate(_field, (6, ()))?;
2044
2045 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
2046
2047 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
2048 ::fidl_next::Constrained::validate(_field, (32, ()))?;
2049
2050 ::fidl_next::Encode::encode(
2051 self.ext_capabilities,
2052 encoder_,
2053 ext_capabilities,
2054 (32, ()),
2055 )?;
2056
2057 let mut _field =
2058 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
2059 ::fidl_next::Constrained::validate(_field, (32, ()))?;
2060
2061 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
2062
2063 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
2064 ::fidl_next::Constrained::validate(_field, (256, ()))?;
2065
2066 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
2067
2068 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2069
2070 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
2071
2072 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2073
2074 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
2075
2076 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
2077
2078 Ok(())
2079 }
2080 }
2081
2082 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E> for &'a PciDevice
2083 where
2084 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2085 ___E: ::fidl_next::Encoder,
2086 {
2087 #[inline]
2088 fn encode(
2089 self,
2090 encoder_: &mut ___E,
2091 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
2092 _: (),
2093 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2094 ::fidl_next::munge! {
2095 let crate::wire::PciDevice {
2096 base_addresses,
2097 capabilities,
2098 ext_capabilities,
2099 config,
2100 bus_id,
2101 device_id,
2102 function_id,
2103
2104 } = out_;
2105 }
2106
2107 ::fidl_next::Encode::encode(&self.base_addresses, encoder_, base_addresses, (6, ()))?;
2108
2109 let mut _field =
2110 unsafe { ::fidl_next::Slot::new_unchecked(base_addresses.as_mut_ptr()) };
2111 ::fidl_next::Constrained::validate(_field, (6, ()))?;
2112
2113 ::fidl_next::Encode::encode(&self.capabilities, encoder_, capabilities, (32, ()))?;
2114
2115 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capabilities.as_mut_ptr()) };
2116 ::fidl_next::Constrained::validate(_field, (32, ()))?;
2117
2118 ::fidl_next::Encode::encode(
2119 &self.ext_capabilities,
2120 encoder_,
2121 ext_capabilities,
2122 (32, ()),
2123 )?;
2124
2125 let mut _field =
2126 unsafe { ::fidl_next::Slot::new_unchecked(ext_capabilities.as_mut_ptr()) };
2127 ::fidl_next::Constrained::validate(_field, (32, ()))?;
2128
2129 ::fidl_next::Encode::encode(&self.config, encoder_, config, (256, ()))?;
2130
2131 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(config.as_mut_ptr()) };
2132 ::fidl_next::Constrained::validate(_field, (256, ()))?;
2133
2134 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
2135
2136 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2137
2138 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
2139
2140 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2141
2142 ::fidl_next::Encode::encode(&self.function_id, encoder_, function_id, ())?;
2143
2144 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(function_id.as_mut_ptr()) };
2145
2146 Ok(())
2147 }
2148 }
2149
2150 unsafe impl<___E>
2151 ::fidl_next::EncodeOption<
2152 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
2153 ___E,
2154 > for PciDevice
2155 where
2156 ___E: ::fidl_next::Encoder + ?Sized,
2157 PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
2158 {
2159 #[inline]
2160 fn encode_option(
2161 this: ::core::option::Option<Self>,
2162 encoder: &mut ___E,
2163 out: &mut ::core::mem::MaybeUninit<
2164 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
2165 >,
2166 _: (),
2167 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2168 if let Some(inner) = this {
2169 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2170 ::fidl_next::wire::Box::encode_present(out);
2171 } else {
2172 ::fidl_next::wire::Box::encode_absent(out);
2173 }
2174
2175 Ok(())
2176 }
2177 }
2178
2179 unsafe impl<'a, ___E>
2180 ::fidl_next::EncodeOption<
2181 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
2182 ___E,
2183 > for &'a PciDevice
2184 where
2185 ___E: ::fidl_next::Encoder + ?Sized,
2186 &'a PciDevice: ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>,
2187 {
2188 #[inline]
2189 fn encode_option(
2190 this: ::core::option::Option<Self>,
2191 encoder: &mut ___E,
2192 out: &mut ::core::mem::MaybeUninit<
2193 ::fidl_next::wire::Box<'static, crate::wire::PciDevice<'static>>,
2194 >,
2195 _: (),
2196 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2197 if let Some(inner) = this {
2198 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2199 ::fidl_next::wire::Box::encode_present(out);
2200 } else {
2201 ::fidl_next::wire::Box::encode_absent(out);
2202 }
2203
2204 Ok(())
2205 }
2206 }
2207
2208 impl<'de> ::fidl_next::FromWire<crate::wire::PciDevice<'de>> for PciDevice {
2209 #[inline]
2210 fn from_wire(wire: crate::wire::PciDevice<'de>) -> Self {
2211 Self {
2212 base_addresses: ::fidl_next::FromWire::from_wire(wire.base_addresses),
2213
2214 capabilities: ::fidl_next::FromWire::from_wire(wire.capabilities),
2215
2216 ext_capabilities: ::fidl_next::FromWire::from_wire(wire.ext_capabilities),
2217
2218 config: ::fidl_next::FromWire::from_wire(wire.config),
2219
2220 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
2221
2222 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
2223
2224 function_id: ::fidl_next::FromWire::from_wire(wire.function_id),
2225 }
2226 }
2227 }
2228
2229 impl<'de> ::fidl_next::FromWireRef<crate::wire::PciDevice<'de>> for PciDevice {
2230 #[inline]
2231 fn from_wire_ref(wire: &crate::wire::PciDevice<'de>) -> Self {
2232 Self {
2233 base_addresses: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_addresses),
2234
2235 capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.capabilities),
2236
2237 ext_capabilities: ::fidl_next::FromWireRef::from_wire_ref(&wire.ext_capabilities),
2238
2239 config: ::fidl_next::FromWireRef::from_wire_ref(&wire.config),
2240
2241 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
2242
2243 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
2244
2245 function_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.function_id),
2246 }
2247 }
2248 }
2249
2250 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2251 pub struct DebugGetDevicesResponse {
2252 pub devices: ::std::vec::Vec<crate::natural::PciDevice>,
2253 }
2254
2255 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugGetDevicesResponse<'static>, ___E>
2256 for DebugGetDevicesResponse
2257 where
2258 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2259 ___E: ::fidl_next::Encoder,
2260 {
2261 #[inline]
2262 fn encode(
2263 self,
2264 encoder_: &mut ___E,
2265 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugGetDevicesResponse<'static>>,
2266 _: (),
2267 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2268 ::fidl_next::munge! {
2269 let crate::wire::DebugGetDevicesResponse {
2270 devices,
2271
2272 } = out_;
2273 }
2274
2275 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
2276
2277 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
2278 ::fidl_next::Constrained::validate(_field, (64, ()))?;
2279
2280 Ok(())
2281 }
2282 }
2283
2284 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugGetDevicesResponse<'static>, ___E>
2285 for &'a DebugGetDevicesResponse
2286 where
2287 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2288 ___E: ::fidl_next::Encoder,
2289 {
2290 #[inline]
2291 fn encode(
2292 self,
2293 encoder_: &mut ___E,
2294 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugGetDevicesResponse<'static>>,
2295 _: (),
2296 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2297 ::fidl_next::munge! {
2298 let crate::wire::DebugGetDevicesResponse {
2299 devices,
2300
2301 } = out_;
2302 }
2303
2304 ::fidl_next::Encode::encode(&self.devices, encoder_, devices, (64, ()))?;
2305
2306 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(devices.as_mut_ptr()) };
2307 ::fidl_next::Constrained::validate(_field, (64, ()))?;
2308
2309 Ok(())
2310 }
2311 }
2312
2313 unsafe impl<___E>
2314 ::fidl_next::EncodeOption<
2315 ::fidl_next::wire::Box<'static, crate::wire::DebugGetDevicesResponse<'static>>,
2316 ___E,
2317 > for DebugGetDevicesResponse
2318 where
2319 ___E: ::fidl_next::Encoder + ?Sized,
2320 DebugGetDevicesResponse:
2321 ::fidl_next::Encode<crate::wire::DebugGetDevicesResponse<'static>, ___E>,
2322 {
2323 #[inline]
2324 fn encode_option(
2325 this: ::core::option::Option<Self>,
2326 encoder: &mut ___E,
2327 out: &mut ::core::mem::MaybeUninit<
2328 ::fidl_next::wire::Box<'static, crate::wire::DebugGetDevicesResponse<'static>>,
2329 >,
2330 _: (),
2331 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2332 if let Some(inner) = this {
2333 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2334 ::fidl_next::wire::Box::encode_present(out);
2335 } else {
2336 ::fidl_next::wire::Box::encode_absent(out);
2337 }
2338
2339 Ok(())
2340 }
2341 }
2342
2343 unsafe impl<'a, ___E>
2344 ::fidl_next::EncodeOption<
2345 ::fidl_next::wire::Box<'static, crate::wire::DebugGetDevicesResponse<'static>>,
2346 ___E,
2347 > for &'a DebugGetDevicesResponse
2348 where
2349 ___E: ::fidl_next::Encoder + ?Sized,
2350 &'a DebugGetDevicesResponse:
2351 ::fidl_next::Encode<crate::wire::DebugGetDevicesResponse<'static>, ___E>,
2352 {
2353 #[inline]
2354 fn encode_option(
2355 this: ::core::option::Option<Self>,
2356 encoder: &mut ___E,
2357 out: &mut ::core::mem::MaybeUninit<
2358 ::fidl_next::wire::Box<'static, crate::wire::DebugGetDevicesResponse<'static>>,
2359 >,
2360 _: (),
2361 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2362 if let Some(inner) = this {
2363 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2364 ::fidl_next::wire::Box::encode_present(out);
2365 } else {
2366 ::fidl_next::wire::Box::encode_absent(out);
2367 }
2368
2369 Ok(())
2370 }
2371 }
2372
2373 impl<'de> ::fidl_next::FromWire<crate::wire::DebugGetDevicesResponse<'de>>
2374 for DebugGetDevicesResponse
2375 {
2376 #[inline]
2377 fn from_wire(wire: crate::wire::DebugGetDevicesResponse<'de>) -> Self {
2378 Self { devices: ::fidl_next::FromWire::from_wire(wire.devices) }
2379 }
2380 }
2381
2382 impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugGetDevicesResponse<'de>>
2383 for DebugGetDevicesResponse
2384 {
2385 #[inline]
2386 fn from_wire_ref(wire: &crate::wire::DebugGetDevicesResponse<'de>) -> Self {
2387 Self { devices: ::fidl_next::FromWireRef::from_wire_ref(&wire.devices) }
2388 }
2389 }
2390
2391 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2392 pub struct DebugReadBarRequest {
2393 pub device: crate::natural::Address,
2394
2395 pub bar_id: u8,
2396
2397 pub offset: u64,
2398
2399 pub size: u64,
2400 }
2401
2402 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugReadBarRequest, ___E>
2403 for DebugReadBarRequest
2404 where
2405 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2406 {
2407 #[inline]
2408 fn encode(
2409 self,
2410 encoder_: &mut ___E,
2411 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarRequest>,
2412 _: (),
2413 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2414 ::fidl_next::munge! {
2415 let crate::wire::DebugReadBarRequest {
2416 device,
2417 bar_id,
2418 offset,
2419 size,
2420
2421 } = out_;
2422 }
2423
2424 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
2425
2426 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
2427
2428 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
2429
2430 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
2431
2432 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
2433
2434 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
2435
2436 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
2437
2438 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
2439
2440 Ok(())
2441 }
2442 }
2443
2444 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugReadBarRequest, ___E>
2445 for &'a DebugReadBarRequest
2446 where
2447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2448 {
2449 #[inline]
2450 fn encode(
2451 self,
2452 encoder_: &mut ___E,
2453 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarRequest>,
2454 _: (),
2455 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2456 ::fidl_next::munge! {
2457 let crate::wire::DebugReadBarRequest {
2458 device,
2459 bar_id,
2460 offset,
2461 size,
2462
2463 } = out_;
2464 }
2465
2466 ::fidl_next::Encode::encode(&self.device, encoder_, device, ())?;
2467
2468 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device.as_mut_ptr()) };
2469
2470 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
2471
2472 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
2473
2474 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
2475
2476 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
2477
2478 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
2479
2480 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
2481
2482 Ok(())
2483 }
2484 }
2485
2486 unsafe impl<___E>
2487 ::fidl_next::EncodeOption<
2488 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarRequest>,
2489 ___E,
2490 > for DebugReadBarRequest
2491 where
2492 ___E: ::fidl_next::Encoder + ?Sized,
2493 DebugReadBarRequest: ::fidl_next::Encode<crate::wire::DebugReadBarRequest, ___E>,
2494 {
2495 #[inline]
2496 fn encode_option(
2497 this: ::core::option::Option<Self>,
2498 encoder: &mut ___E,
2499 out: &mut ::core::mem::MaybeUninit<
2500 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarRequest>,
2501 >,
2502 _: (),
2503 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2504 if let Some(inner) = this {
2505 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2506 ::fidl_next::wire::Box::encode_present(out);
2507 } else {
2508 ::fidl_next::wire::Box::encode_absent(out);
2509 }
2510
2511 Ok(())
2512 }
2513 }
2514
2515 unsafe impl<'a, ___E>
2516 ::fidl_next::EncodeOption<
2517 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarRequest>,
2518 ___E,
2519 > for &'a DebugReadBarRequest
2520 where
2521 ___E: ::fidl_next::Encoder + ?Sized,
2522 &'a DebugReadBarRequest: ::fidl_next::Encode<crate::wire::DebugReadBarRequest, ___E>,
2523 {
2524 #[inline]
2525 fn encode_option(
2526 this: ::core::option::Option<Self>,
2527 encoder: &mut ___E,
2528 out: &mut ::core::mem::MaybeUninit<
2529 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarRequest>,
2530 >,
2531 _: (),
2532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2533 if let Some(inner) = this {
2534 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2535 ::fidl_next::wire::Box::encode_present(out);
2536 } else {
2537 ::fidl_next::wire::Box::encode_absent(out);
2538 }
2539
2540 Ok(())
2541 }
2542 }
2543
2544 impl ::fidl_next::FromWire<crate::wire::DebugReadBarRequest> for DebugReadBarRequest {
2545 #[inline]
2546 fn from_wire(wire: crate::wire::DebugReadBarRequest) -> Self {
2547 Self {
2548 device: ::fidl_next::FromWire::from_wire(wire.device),
2549
2550 bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id),
2551
2552 offset: ::fidl_next::FromWire::from_wire(wire.offset),
2553
2554 size: ::fidl_next::FromWire::from_wire(wire.size),
2555 }
2556 }
2557 }
2558
2559 impl ::fidl_next::FromWireRef<crate::wire::DebugReadBarRequest> for DebugReadBarRequest {
2560 #[inline]
2561 fn from_wire_ref(wire: &crate::wire::DebugReadBarRequest) -> Self {
2562 Self {
2563 device: ::fidl_next::FromWireRef::from_wire_ref(&wire.device),
2564
2565 bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id),
2566
2567 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
2568
2569 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
2570 }
2571 }
2572 }
2573
2574 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2575 pub struct DebugReadBarResponse {
2576 pub buffer: ::std::vec::Vec<u8>,
2577 }
2578
2579 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugReadBarResponse<'static>, ___E>
2580 for DebugReadBarResponse
2581 where
2582 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2583 ___E: ::fidl_next::Encoder,
2584 {
2585 #[inline]
2586 fn encode(
2587 self,
2588 encoder_: &mut ___E,
2589 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarResponse<'static>>,
2590 _: (),
2591 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2592 ::fidl_next::munge! {
2593 let crate::wire::DebugReadBarResponse {
2594 buffer,
2595
2596 } = out_;
2597 }
2598
2599 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
2600
2601 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
2602 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2603
2604 Ok(())
2605 }
2606 }
2607
2608 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugReadBarResponse<'static>, ___E>
2609 for &'a DebugReadBarResponse
2610 where
2611 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2612 ___E: ::fidl_next::Encoder,
2613 {
2614 #[inline]
2615 fn encode(
2616 self,
2617 encoder_: &mut ___E,
2618 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarResponse<'static>>,
2619 _: (),
2620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2621 ::fidl_next::munge! {
2622 let crate::wire::DebugReadBarResponse {
2623 buffer,
2624
2625 } = out_;
2626 }
2627
2628 ::fidl_next::Encode::encode(&self.buffer, encoder_, buffer, (4294967295, ()))?;
2629
2630 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
2631 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2632
2633 Ok(())
2634 }
2635 }
2636
2637 unsafe impl<___E>
2638 ::fidl_next::EncodeOption<
2639 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarResponse<'static>>,
2640 ___E,
2641 > for DebugReadBarResponse
2642 where
2643 ___E: ::fidl_next::Encoder + ?Sized,
2644 DebugReadBarResponse: ::fidl_next::Encode<crate::wire::DebugReadBarResponse<'static>, ___E>,
2645 {
2646 #[inline]
2647 fn encode_option(
2648 this: ::core::option::Option<Self>,
2649 encoder: &mut ___E,
2650 out: &mut ::core::mem::MaybeUninit<
2651 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarResponse<'static>>,
2652 >,
2653 _: (),
2654 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2655 if let Some(inner) = this {
2656 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2657 ::fidl_next::wire::Box::encode_present(out);
2658 } else {
2659 ::fidl_next::wire::Box::encode_absent(out);
2660 }
2661
2662 Ok(())
2663 }
2664 }
2665
2666 unsafe impl<'a, ___E>
2667 ::fidl_next::EncodeOption<
2668 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarResponse<'static>>,
2669 ___E,
2670 > for &'a DebugReadBarResponse
2671 where
2672 ___E: ::fidl_next::Encoder + ?Sized,
2673 &'a DebugReadBarResponse:
2674 ::fidl_next::Encode<crate::wire::DebugReadBarResponse<'static>, ___E>,
2675 {
2676 #[inline]
2677 fn encode_option(
2678 this: ::core::option::Option<Self>,
2679 encoder: &mut ___E,
2680 out: &mut ::core::mem::MaybeUninit<
2681 ::fidl_next::wire::Box<'static, crate::wire::DebugReadBarResponse<'static>>,
2682 >,
2683 _: (),
2684 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2685 if let Some(inner) = this {
2686 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2687 ::fidl_next::wire::Box::encode_present(out);
2688 } else {
2689 ::fidl_next::wire::Box::encode_absent(out);
2690 }
2691
2692 Ok(())
2693 }
2694 }
2695
2696 impl<'de> ::fidl_next::FromWire<crate::wire::DebugReadBarResponse<'de>> for DebugReadBarResponse {
2697 #[inline]
2698 fn from_wire(wire: crate::wire::DebugReadBarResponse<'de>) -> Self {
2699 Self { buffer: ::fidl_next::FromWire::from_wire(wire.buffer) }
2700 }
2701 }
2702
2703 impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugReadBarResponse<'de>>
2704 for DebugReadBarResponse
2705 {
2706 #[inline]
2707 fn from_wire_ref(wire: &crate::wire::DebugReadBarResponse<'de>) -> Self {
2708 Self { buffer: ::fidl_next::FromWireRef::from_wire_ref(&wire.buffer) }
2709 }
2710 }
2711
2712 pub type Padding = ();
2713
2714 #[doc = " Device specific information from a device\'s configuration header.\n PCI Local Bus Specification v3, chapter 6.1.\n"]
2715 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2716 #[repr(C)]
2717 pub struct DeviceInfo {
2718 pub vendor_id: u16,
2719
2720 pub device_id: u16,
2721
2722 pub base_class: u8,
2723
2724 pub sub_class: u8,
2725
2726 pub program_interface: u8,
2727
2728 pub revision_id: u8,
2729
2730 pub bus_id: u8,
2731
2732 pub dev_id: u8,
2733
2734 pub func_id: u8,
2735
2736 pub padding: crate::natural::Padding,
2737 }
2738
2739 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for DeviceInfo
2740 where
2741 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2742 {
2743 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DeviceInfo> = unsafe {
2744 ::fidl_next::CopyOptimization::enable_if(
2745 true
2746
2747 && <
2748 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2749 >::COPY_OPTIMIZATION.is_enabled()
2750
2751 && <
2752 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
2753 >::COPY_OPTIMIZATION.is_enabled()
2754
2755 && <
2756 u8 as ::fidl_next::Encode<u8, ___E>
2757 >::COPY_OPTIMIZATION.is_enabled()
2758
2759 && <
2760 u8 as ::fidl_next::Encode<u8, ___E>
2761 >::COPY_OPTIMIZATION.is_enabled()
2762
2763 && <
2764 u8 as ::fidl_next::Encode<u8, ___E>
2765 >::COPY_OPTIMIZATION.is_enabled()
2766
2767 && <
2768 u8 as ::fidl_next::Encode<u8, ___E>
2769 >::COPY_OPTIMIZATION.is_enabled()
2770
2771 && <
2772 u8 as ::fidl_next::Encode<u8, ___E>
2773 >::COPY_OPTIMIZATION.is_enabled()
2774
2775 && <
2776 u8 as ::fidl_next::Encode<u8, ___E>
2777 >::COPY_OPTIMIZATION.is_enabled()
2778
2779 && <
2780 u8 as ::fidl_next::Encode<u8, ___E>
2781 >::COPY_OPTIMIZATION.is_enabled()
2782
2783 && <
2784 crate::natural::Padding as ::fidl_next::Encode<crate::wire::Padding, ___E>
2785 >::COPY_OPTIMIZATION.is_enabled()
2786
2787 )
2788 };
2789
2790 #[inline]
2791 fn encode(
2792 self,
2793 encoder_: &mut ___E,
2794 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2795 _: (),
2796 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2797 ::fidl_next::munge! {
2798 let crate::wire::DeviceInfo {
2799 vendor_id,
2800 device_id,
2801 base_class,
2802 sub_class,
2803 program_interface,
2804 revision_id,
2805 bus_id,
2806 dev_id,
2807 func_id,
2808 padding,
2809
2810 } = out_;
2811 }
2812
2813 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
2814
2815 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2816
2817 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
2818
2819 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2820
2821 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
2822
2823 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2824
2825 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
2826
2827 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2828
2829 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
2830
2831 let mut _field =
2832 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2833
2834 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
2835
2836 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2837
2838 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
2839
2840 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2841
2842 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
2843
2844 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2845
2846 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
2847
2848 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2849
2850 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
2851
2852 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2853
2854 Ok(())
2855 }
2856 }
2857
2858 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceInfo, ___E> for &'a DeviceInfo
2859 where
2860 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2861 {
2862 #[inline]
2863 fn encode(
2864 self,
2865 encoder_: &mut ___E,
2866 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
2867 _: (),
2868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2869 ::fidl_next::munge! {
2870 let crate::wire::DeviceInfo {
2871 vendor_id,
2872 device_id,
2873 base_class,
2874 sub_class,
2875 program_interface,
2876 revision_id,
2877 bus_id,
2878 dev_id,
2879 func_id,
2880 padding,
2881
2882 } = out_;
2883 }
2884
2885 ::fidl_next::Encode::encode(&self.vendor_id, encoder_, vendor_id, ())?;
2886
2887 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vendor_id.as_mut_ptr()) };
2888
2889 ::fidl_next::Encode::encode(&self.device_id, encoder_, device_id, ())?;
2890
2891 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(device_id.as_mut_ptr()) };
2892
2893 ::fidl_next::Encode::encode(&self.base_class, encoder_, base_class, ())?;
2894
2895 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base_class.as_mut_ptr()) };
2896
2897 ::fidl_next::Encode::encode(&self.sub_class, encoder_, sub_class, ())?;
2898
2899 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sub_class.as_mut_ptr()) };
2900
2901 ::fidl_next::Encode::encode(&self.program_interface, encoder_, program_interface, ())?;
2902
2903 let mut _field =
2904 unsafe { ::fidl_next::Slot::new_unchecked(program_interface.as_mut_ptr()) };
2905
2906 ::fidl_next::Encode::encode(&self.revision_id, encoder_, revision_id, ())?;
2907
2908 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(revision_id.as_mut_ptr()) };
2909
2910 ::fidl_next::Encode::encode(&self.bus_id, encoder_, bus_id, ())?;
2911
2912 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bus_id.as_mut_ptr()) };
2913
2914 ::fidl_next::Encode::encode(&self.dev_id, encoder_, dev_id, ())?;
2915
2916 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dev_id.as_mut_ptr()) };
2917
2918 ::fidl_next::Encode::encode(&self.func_id, encoder_, func_id, ())?;
2919
2920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(func_id.as_mut_ptr()) };
2921
2922 ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
2923
2924 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
2925
2926 Ok(())
2927 }
2928 }
2929
2930 unsafe impl<___E>
2931 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2932 for DeviceInfo
2933 where
2934 ___E: ::fidl_next::Encoder + ?Sized,
2935 DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2936 {
2937 #[inline]
2938 fn encode_option(
2939 this: ::core::option::Option<Self>,
2940 encoder: &mut ___E,
2941 out: &mut ::core::mem::MaybeUninit<
2942 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2943 >,
2944 _: (),
2945 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2946 if let Some(inner) = this {
2947 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2948 ::fidl_next::wire::Box::encode_present(out);
2949 } else {
2950 ::fidl_next::wire::Box::encode_absent(out);
2951 }
2952
2953 Ok(())
2954 }
2955 }
2956
2957 unsafe impl<'a, ___E>
2958 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>, ___E>
2959 for &'a DeviceInfo
2960 where
2961 ___E: ::fidl_next::Encoder + ?Sized,
2962 &'a DeviceInfo: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
2963 {
2964 #[inline]
2965 fn encode_option(
2966 this: ::core::option::Option<Self>,
2967 encoder: &mut ___E,
2968 out: &mut ::core::mem::MaybeUninit<
2969 ::fidl_next::wire::Box<'static, crate::wire::DeviceInfo>,
2970 >,
2971 _: (),
2972 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2973 if let Some(inner) = this {
2974 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2975 ::fidl_next::wire::Box::encode_present(out);
2976 } else {
2977 ::fidl_next::wire::Box::encode_absent(out);
2978 }
2979
2980 Ok(())
2981 }
2982 }
2983
2984 impl ::fidl_next::FromWire<crate::wire::DeviceInfo> for DeviceInfo {
2985 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DeviceInfo, Self> = unsafe {
2986 ::fidl_next::CopyOptimization::enable_if(
2987 true
2988
2989 && <
2990 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2991 >::COPY_OPTIMIZATION.is_enabled()
2992
2993 && <
2994 u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>
2995 >::COPY_OPTIMIZATION.is_enabled()
2996
2997 && <
2998 u8 as ::fidl_next::FromWire<u8>
2999 >::COPY_OPTIMIZATION.is_enabled()
3000
3001 && <
3002 u8 as ::fidl_next::FromWire<u8>
3003 >::COPY_OPTIMIZATION.is_enabled()
3004
3005 && <
3006 u8 as ::fidl_next::FromWire<u8>
3007 >::COPY_OPTIMIZATION.is_enabled()
3008
3009 && <
3010 u8 as ::fidl_next::FromWire<u8>
3011 >::COPY_OPTIMIZATION.is_enabled()
3012
3013 && <
3014 u8 as ::fidl_next::FromWire<u8>
3015 >::COPY_OPTIMIZATION.is_enabled()
3016
3017 && <
3018 u8 as ::fidl_next::FromWire<u8>
3019 >::COPY_OPTIMIZATION.is_enabled()
3020
3021 && <
3022 u8 as ::fidl_next::FromWire<u8>
3023 >::COPY_OPTIMIZATION.is_enabled()
3024
3025 && <
3026 crate::natural::Padding as ::fidl_next::FromWire<crate::wire::Padding>
3027 >::COPY_OPTIMIZATION.is_enabled()
3028
3029 )
3030 };
3031
3032 #[inline]
3033 fn from_wire(wire: crate::wire::DeviceInfo) -> Self {
3034 Self {
3035 vendor_id: ::fidl_next::FromWire::from_wire(wire.vendor_id),
3036
3037 device_id: ::fidl_next::FromWire::from_wire(wire.device_id),
3038
3039 base_class: ::fidl_next::FromWire::from_wire(wire.base_class),
3040
3041 sub_class: ::fidl_next::FromWire::from_wire(wire.sub_class),
3042
3043 program_interface: ::fidl_next::FromWire::from_wire(wire.program_interface),
3044
3045 revision_id: ::fidl_next::FromWire::from_wire(wire.revision_id),
3046
3047 bus_id: ::fidl_next::FromWire::from_wire(wire.bus_id),
3048
3049 dev_id: ::fidl_next::FromWire::from_wire(wire.dev_id),
3050
3051 func_id: ::fidl_next::FromWire::from_wire(wire.func_id),
3052
3053 padding: ::fidl_next::FromWire::from_wire(wire.padding),
3054 }
3055 }
3056 }
3057
3058 impl ::fidl_next::FromWireRef<crate::wire::DeviceInfo> for DeviceInfo {
3059 #[inline]
3060 fn from_wire_ref(wire: &crate::wire::DeviceInfo) -> Self {
3061 Self {
3062 vendor_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.vendor_id),
3063
3064 device_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.device_id),
3065
3066 base_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.base_class),
3067
3068 sub_class: ::fidl_next::FromWireRef::from_wire_ref(&wire.sub_class),
3069
3070 program_interface: ::fidl_next::FromWireRef::from_wire_ref(&wire.program_interface),
3071
3072 revision_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.revision_id),
3073
3074 bus_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bus_id),
3075
3076 dev_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dev_id),
3077
3078 func_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.func_id),
3079
3080 padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
3081 }
3082 }
3083 }
3084
3085 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3086 #[repr(C)]
3087 pub struct DeviceGetDeviceInfoResponse {
3088 pub info: crate::natural::DeviceInfo,
3089 }
3090
3091 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
3092 for DeviceGetDeviceInfoResponse
3093 where
3094 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3095 {
3096 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3097 Self,
3098 crate::wire::DeviceGetDeviceInfoResponse,
3099 > = unsafe {
3100 ::fidl_next::CopyOptimization::enable_if(
3101 true && <crate::natural::DeviceInfo as ::fidl_next::Encode<
3102 crate::wire::DeviceInfo,
3103 ___E,
3104 >>::COPY_OPTIMIZATION
3105 .is_enabled(),
3106 )
3107 };
3108
3109 #[inline]
3110 fn encode(
3111 self,
3112 encoder_: &mut ___E,
3113 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::DeviceGetDeviceInfoResponse {
3118 info,
3119
3120 } = out_;
3121 }
3122
3123 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
3124
3125 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
3126
3127 Ok(())
3128 }
3129 }
3130
3131 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
3132 for &'a DeviceGetDeviceInfoResponse
3133 where
3134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3135 {
3136 #[inline]
3137 fn encode(
3138 self,
3139 encoder_: &mut ___E,
3140 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
3141 _: (),
3142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3143 ::fidl_next::munge! {
3144 let crate::wire::DeviceGetDeviceInfoResponse {
3145 info,
3146
3147 } = out_;
3148 }
3149
3150 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
3151
3152 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
3153
3154 Ok(())
3155 }
3156 }
3157
3158 unsafe impl<___E>
3159 ::fidl_next::EncodeOption<
3160 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3161 ___E,
3162 > for DeviceGetDeviceInfoResponse
3163 where
3164 ___E: ::fidl_next::Encoder + ?Sized,
3165 DeviceGetDeviceInfoResponse:
3166 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
3167 {
3168 #[inline]
3169 fn encode_option(
3170 this: ::core::option::Option<Self>,
3171 encoder: &mut ___E,
3172 out: &mut ::core::mem::MaybeUninit<
3173 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3174 >,
3175 _: (),
3176 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3177 if let Some(inner) = this {
3178 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3179 ::fidl_next::wire::Box::encode_present(out);
3180 } else {
3181 ::fidl_next::wire::Box::encode_absent(out);
3182 }
3183
3184 Ok(())
3185 }
3186 }
3187
3188 unsafe impl<'a, ___E>
3189 ::fidl_next::EncodeOption<
3190 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3191 ___E,
3192 > for &'a DeviceGetDeviceInfoResponse
3193 where
3194 ___E: ::fidl_next::Encoder + ?Sized,
3195 &'a DeviceGetDeviceInfoResponse:
3196 ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>,
3197 {
3198 #[inline]
3199 fn encode_option(
3200 this: ::core::option::Option<Self>,
3201 encoder: &mut ___E,
3202 out: &mut ::core::mem::MaybeUninit<
3203 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetDeviceInfoResponse>,
3204 >,
3205 _: (),
3206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3207 if let Some(inner) = this {
3208 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3209 ::fidl_next::wire::Box::encode_present(out);
3210 } else {
3211 ::fidl_next::wire::Box::encode_absent(out);
3212 }
3213
3214 Ok(())
3215 }
3216 }
3217
3218 impl ::fidl_next::FromWire<crate::wire::DeviceGetDeviceInfoResponse>
3219 for DeviceGetDeviceInfoResponse
3220 {
3221 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3222 crate::wire::DeviceGetDeviceInfoResponse,
3223 Self,
3224 > = unsafe {
3225 ::fidl_next::CopyOptimization::enable_if(
3226 true && <crate::natural::DeviceInfo as ::fidl_next::FromWire<
3227 crate::wire::DeviceInfo,
3228 >>::COPY_OPTIMIZATION
3229 .is_enabled(),
3230 )
3231 };
3232
3233 #[inline]
3234 fn from_wire(wire: crate::wire::DeviceGetDeviceInfoResponse) -> Self {
3235 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
3236 }
3237 }
3238
3239 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetDeviceInfoResponse>
3240 for DeviceGetDeviceInfoResponse
3241 {
3242 #[inline]
3243 fn from_wire_ref(wire: &crate::wire::DeviceGetDeviceInfoResponse) -> Self {
3244 Self { info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info) }
3245 }
3246 }
3247
3248 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3249 #[repr(C)]
3250 pub struct DeviceGetBarRequest {
3251 pub bar_id: u32,
3252 }
3253
3254 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
3255 for DeviceGetBarRequest
3256 where
3257 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3258 {
3259 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3260 Self,
3261 crate::wire::DeviceGetBarRequest,
3262 > = unsafe {
3263 ::fidl_next::CopyOptimization::enable_if(
3264 true
3265
3266 && <
3267 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3268 >::COPY_OPTIMIZATION.is_enabled()
3269
3270 )
3271 };
3272
3273 #[inline]
3274 fn encode(
3275 self,
3276 encoder_: &mut ___E,
3277 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
3278 _: (),
3279 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3280 ::fidl_next::munge! {
3281 let crate::wire::DeviceGetBarRequest {
3282 bar_id,
3283
3284 } = out_;
3285 }
3286
3287 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
3288
3289 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
3290
3291 Ok(())
3292 }
3293 }
3294
3295 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
3296 for &'a DeviceGetBarRequest
3297 where
3298 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3299 {
3300 #[inline]
3301 fn encode(
3302 self,
3303 encoder_: &mut ___E,
3304 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
3305 _: (),
3306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3307 ::fidl_next::munge! {
3308 let crate::wire::DeviceGetBarRequest {
3309 bar_id,
3310
3311 } = out_;
3312 }
3313
3314 ::fidl_next::Encode::encode(&self.bar_id, encoder_, bar_id, ())?;
3315
3316 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bar_id.as_mut_ptr()) };
3317
3318 Ok(())
3319 }
3320 }
3321
3322 unsafe impl<___E>
3323 ::fidl_next::EncodeOption<
3324 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3325 ___E,
3326 > for DeviceGetBarRequest
3327 where
3328 ___E: ::fidl_next::Encoder + ?Sized,
3329 DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3330 {
3331 #[inline]
3332 fn encode_option(
3333 this: ::core::option::Option<Self>,
3334 encoder: &mut ___E,
3335 out: &mut ::core::mem::MaybeUninit<
3336 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3337 >,
3338 _: (),
3339 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3340 if let Some(inner) = this {
3341 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3342 ::fidl_next::wire::Box::encode_present(out);
3343 } else {
3344 ::fidl_next::wire::Box::encode_absent(out);
3345 }
3346
3347 Ok(())
3348 }
3349 }
3350
3351 unsafe impl<'a, ___E>
3352 ::fidl_next::EncodeOption<
3353 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3354 ___E,
3355 > for &'a DeviceGetBarRequest
3356 where
3357 ___E: ::fidl_next::Encoder + ?Sized,
3358 &'a DeviceGetBarRequest: ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>,
3359 {
3360 #[inline]
3361 fn encode_option(
3362 this: ::core::option::Option<Self>,
3363 encoder: &mut ___E,
3364 out: &mut ::core::mem::MaybeUninit<
3365 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBarRequest>,
3366 >,
3367 _: (),
3368 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3369 if let Some(inner) = this {
3370 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3371 ::fidl_next::wire::Box::encode_present(out);
3372 } else {
3373 ::fidl_next::wire::Box::encode_absent(out);
3374 }
3375
3376 Ok(())
3377 }
3378 }
3379
3380 impl ::fidl_next::FromWire<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3381 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3382 crate::wire::DeviceGetBarRequest,
3383 Self,
3384 > = unsafe {
3385 ::fidl_next::CopyOptimization::enable_if(
3386 true
3387 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3388 .is_enabled(),
3389 )
3390 };
3391
3392 #[inline]
3393 fn from_wire(wire: crate::wire::DeviceGetBarRequest) -> Self {
3394 Self { bar_id: ::fidl_next::FromWire::from_wire(wire.bar_id) }
3395 }
3396 }
3397
3398 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBarRequest> for DeviceGetBarRequest {
3399 #[inline]
3400 fn from_wire_ref(wire: &crate::wire::DeviceGetBarRequest) -> Self {
3401 Self { bar_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.bar_id) }
3402 }
3403 }
3404
3405 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3406 #[repr(C)]
3407 pub struct DeviceSetBusMasteringRequest {
3408 pub enabled: bool,
3409 }
3410
3411 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3412 for DeviceSetBusMasteringRequest
3413 where
3414 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3415 {
3416 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3417 Self,
3418 crate::wire::DeviceSetBusMasteringRequest,
3419 > = unsafe {
3420 ::fidl_next::CopyOptimization::enable_if(
3421 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
3422 )
3423 };
3424
3425 #[inline]
3426 fn encode(
3427 self,
3428 encoder_: &mut ___E,
3429 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3430 _: (),
3431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3432 ::fidl_next::munge! {
3433 let crate::wire::DeviceSetBusMasteringRequest {
3434 enabled,
3435
3436 } = out_;
3437 }
3438
3439 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
3440
3441 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3442
3443 Ok(())
3444 }
3445 }
3446
3447 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
3448 for &'a DeviceSetBusMasteringRequest
3449 where
3450 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3451 {
3452 #[inline]
3453 fn encode(
3454 self,
3455 encoder_: &mut ___E,
3456 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
3457 _: (),
3458 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3459 ::fidl_next::munge! {
3460 let crate::wire::DeviceSetBusMasteringRequest {
3461 enabled,
3462
3463 } = out_;
3464 }
3465
3466 ::fidl_next::Encode::encode(&self.enabled, encoder_, enabled, ())?;
3467
3468 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(enabled.as_mut_ptr()) };
3469
3470 Ok(())
3471 }
3472 }
3473
3474 unsafe impl<___E>
3475 ::fidl_next::EncodeOption<
3476 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3477 ___E,
3478 > for DeviceSetBusMasteringRequest
3479 where
3480 ___E: ::fidl_next::Encoder + ?Sized,
3481 DeviceSetBusMasteringRequest:
3482 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3483 {
3484 #[inline]
3485 fn encode_option(
3486 this: ::core::option::Option<Self>,
3487 encoder: &mut ___E,
3488 out: &mut ::core::mem::MaybeUninit<
3489 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3490 >,
3491 _: (),
3492 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3493 if let Some(inner) = this {
3494 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3495 ::fidl_next::wire::Box::encode_present(out);
3496 } else {
3497 ::fidl_next::wire::Box::encode_absent(out);
3498 }
3499
3500 Ok(())
3501 }
3502 }
3503
3504 unsafe impl<'a, ___E>
3505 ::fidl_next::EncodeOption<
3506 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3507 ___E,
3508 > for &'a DeviceSetBusMasteringRequest
3509 where
3510 ___E: ::fidl_next::Encoder + ?Sized,
3511 &'a DeviceSetBusMasteringRequest:
3512 ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>,
3513 {
3514 #[inline]
3515 fn encode_option(
3516 this: ::core::option::Option<Self>,
3517 encoder: &mut ___E,
3518 out: &mut ::core::mem::MaybeUninit<
3519 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetBusMasteringRequest>,
3520 >,
3521 _: (),
3522 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3523 if let Some(inner) = this {
3524 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3525 ::fidl_next::wire::Box::encode_present(out);
3526 } else {
3527 ::fidl_next::wire::Box::encode_absent(out);
3528 }
3529
3530 Ok(())
3531 }
3532 }
3533
3534 impl ::fidl_next::FromWire<crate::wire::DeviceSetBusMasteringRequest>
3535 for DeviceSetBusMasteringRequest
3536 {
3537 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3538 crate::wire::DeviceSetBusMasteringRequest,
3539 Self,
3540 > = unsafe {
3541 ::fidl_next::CopyOptimization::enable_if(
3542 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
3543 )
3544 };
3545
3546 #[inline]
3547 fn from_wire(wire: crate::wire::DeviceSetBusMasteringRequest) -> Self {
3548 Self { enabled: ::fidl_next::FromWire::from_wire(wire.enabled) }
3549 }
3550 }
3551
3552 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetBusMasteringRequest>
3553 for DeviceSetBusMasteringRequest
3554 {
3555 #[inline]
3556 fn from_wire_ref(wire: &crate::wire::DeviceSetBusMasteringRequest) -> Self {
3557 Self { enabled: ::fidl_next::FromWireRef::from_wire_ref(&wire.enabled) }
3558 }
3559 }
3560
3561 pub type DeviceSetBusMasteringResponse = ();
3562
3563 pub type DeviceResetDeviceResponse = ();
3564
3565 pub type DeviceAckInterruptResponse = ();
3566
3567 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3568 #[repr(C)]
3569 pub struct DeviceMapInterruptRequest {
3570 pub which_irq: u32,
3571 }
3572
3573 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3574 for DeviceMapInterruptRequest
3575 where
3576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3577 {
3578 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3579 Self,
3580 crate::wire::DeviceMapInterruptRequest,
3581 > = unsafe {
3582 ::fidl_next::CopyOptimization::enable_if(
3583 true
3584
3585 && <
3586 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3587 >::COPY_OPTIMIZATION.is_enabled()
3588
3589 )
3590 };
3591
3592 #[inline]
3593 fn encode(
3594 self,
3595 encoder_: &mut ___E,
3596 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3597 _: (),
3598 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3599 ::fidl_next::munge! {
3600 let crate::wire::DeviceMapInterruptRequest {
3601 which_irq,
3602
3603 } = out_;
3604 }
3605
3606 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
3607
3608 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3609
3610 Ok(())
3611 }
3612 }
3613
3614 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
3615 for &'a DeviceMapInterruptRequest
3616 where
3617 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3618 {
3619 #[inline]
3620 fn encode(
3621 self,
3622 encoder_: &mut ___E,
3623 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
3624 _: (),
3625 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3626 ::fidl_next::munge! {
3627 let crate::wire::DeviceMapInterruptRequest {
3628 which_irq,
3629
3630 } = out_;
3631 }
3632
3633 ::fidl_next::Encode::encode(&self.which_irq, encoder_, which_irq, ())?;
3634
3635 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(which_irq.as_mut_ptr()) };
3636
3637 Ok(())
3638 }
3639 }
3640
3641 unsafe impl<___E>
3642 ::fidl_next::EncodeOption<
3643 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3644 ___E,
3645 > for DeviceMapInterruptRequest
3646 where
3647 ___E: ::fidl_next::Encoder + ?Sized,
3648 DeviceMapInterruptRequest:
3649 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3650 {
3651 #[inline]
3652 fn encode_option(
3653 this: ::core::option::Option<Self>,
3654 encoder: &mut ___E,
3655 out: &mut ::core::mem::MaybeUninit<
3656 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3657 >,
3658 _: (),
3659 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3660 if let Some(inner) = this {
3661 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3662 ::fidl_next::wire::Box::encode_present(out);
3663 } else {
3664 ::fidl_next::wire::Box::encode_absent(out);
3665 }
3666
3667 Ok(())
3668 }
3669 }
3670
3671 unsafe impl<'a, ___E>
3672 ::fidl_next::EncodeOption<
3673 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3674 ___E,
3675 > for &'a DeviceMapInterruptRequest
3676 where
3677 ___E: ::fidl_next::Encoder + ?Sized,
3678 &'a DeviceMapInterruptRequest:
3679 ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>,
3680 {
3681 #[inline]
3682 fn encode_option(
3683 this: ::core::option::Option<Self>,
3684 encoder: &mut ___E,
3685 out: &mut ::core::mem::MaybeUninit<
3686 ::fidl_next::wire::Box<'static, crate::wire::DeviceMapInterruptRequest>,
3687 >,
3688 _: (),
3689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3690 if let Some(inner) = this {
3691 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3692 ::fidl_next::wire::Box::encode_present(out);
3693 } else {
3694 ::fidl_next::wire::Box::encode_absent(out);
3695 }
3696
3697 Ok(())
3698 }
3699 }
3700
3701 impl ::fidl_next::FromWire<crate::wire::DeviceMapInterruptRequest> for DeviceMapInterruptRequest {
3702 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3703 crate::wire::DeviceMapInterruptRequest,
3704 Self,
3705 > = unsafe {
3706 ::fidl_next::CopyOptimization::enable_if(
3707 true
3708 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3709 .is_enabled(),
3710 )
3711 };
3712
3713 #[inline]
3714 fn from_wire(wire: crate::wire::DeviceMapInterruptRequest) -> Self {
3715 Self { which_irq: ::fidl_next::FromWire::from_wire(wire.which_irq) }
3716 }
3717 }
3718
3719 impl ::fidl_next::FromWireRef<crate::wire::DeviceMapInterruptRequest>
3720 for DeviceMapInterruptRequest
3721 {
3722 #[inline]
3723 fn from_wire_ref(wire: &crate::wire::DeviceMapInterruptRequest) -> Self {
3724 Self { which_irq: ::fidl_next::FromWireRef::from_wire_ref(&wire.which_irq) }
3725 }
3726 }
3727
3728 #[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"]
3729 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3730 #[repr(C)]
3731 pub struct InterruptModes {
3732 pub has_legacy: bool,
3733
3734 pub msi_count: u8,
3735
3736 pub msix_count: u16,
3737 }
3738
3739 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for InterruptModes
3740 where
3741 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3742 {
3743 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InterruptModes> = unsafe {
3744 ::fidl_next::CopyOptimization::enable_if(
3745 true
3746
3747 && <
3748 bool as ::fidl_next::Encode<bool, ___E>
3749 >::COPY_OPTIMIZATION.is_enabled()
3750
3751 && <
3752 u8 as ::fidl_next::Encode<u8, ___E>
3753 >::COPY_OPTIMIZATION.is_enabled()
3754
3755 && <
3756 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
3757 >::COPY_OPTIMIZATION.is_enabled()
3758
3759 )
3760 };
3761
3762 #[inline]
3763 fn encode(
3764 self,
3765 encoder_: &mut ___E,
3766 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3767 _: (),
3768 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3769 ::fidl_next::munge! {
3770 let crate::wire::InterruptModes {
3771 has_legacy,
3772 msi_count,
3773 msix_count,
3774
3775 } = out_;
3776 }
3777
3778 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
3779
3780 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3781
3782 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
3783
3784 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3785
3786 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
3787
3788 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3789
3790 Ok(())
3791 }
3792 }
3793
3794 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptModes, ___E> for &'a InterruptModes
3795 where
3796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3797 {
3798 #[inline]
3799 fn encode(
3800 self,
3801 encoder_: &mut ___E,
3802 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
3803 _: (),
3804 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3805 ::fidl_next::munge! {
3806 let crate::wire::InterruptModes {
3807 has_legacy,
3808 msi_count,
3809 msix_count,
3810
3811 } = out_;
3812 }
3813
3814 ::fidl_next::Encode::encode(&self.has_legacy, encoder_, has_legacy, ())?;
3815
3816 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(has_legacy.as_mut_ptr()) };
3817
3818 ::fidl_next::Encode::encode(&self.msi_count, encoder_, msi_count, ())?;
3819
3820 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msi_count.as_mut_ptr()) };
3821
3822 ::fidl_next::Encode::encode(&self.msix_count, encoder_, msix_count, ())?;
3823
3824 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(msix_count.as_mut_ptr()) };
3825
3826 Ok(())
3827 }
3828 }
3829
3830 unsafe impl<___E>
3831 ::fidl_next::EncodeOption<
3832 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3833 ___E,
3834 > for InterruptModes
3835 where
3836 ___E: ::fidl_next::Encoder + ?Sized,
3837 InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3838 {
3839 #[inline]
3840 fn encode_option(
3841 this: ::core::option::Option<Self>,
3842 encoder: &mut ___E,
3843 out: &mut ::core::mem::MaybeUninit<
3844 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3845 >,
3846 _: (),
3847 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3848 if let Some(inner) = this {
3849 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3850 ::fidl_next::wire::Box::encode_present(out);
3851 } else {
3852 ::fidl_next::wire::Box::encode_absent(out);
3853 }
3854
3855 Ok(())
3856 }
3857 }
3858
3859 unsafe impl<'a, ___E>
3860 ::fidl_next::EncodeOption<
3861 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3862 ___E,
3863 > for &'a InterruptModes
3864 where
3865 ___E: ::fidl_next::Encoder + ?Sized,
3866 &'a InterruptModes: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
3867 {
3868 #[inline]
3869 fn encode_option(
3870 this: ::core::option::Option<Self>,
3871 encoder: &mut ___E,
3872 out: &mut ::core::mem::MaybeUninit<
3873 ::fidl_next::wire::Box<'static, crate::wire::InterruptModes>,
3874 >,
3875 _: (),
3876 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3877 if let Some(inner) = this {
3878 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3879 ::fidl_next::wire::Box::encode_present(out);
3880 } else {
3881 ::fidl_next::wire::Box::encode_absent(out);
3882 }
3883
3884 Ok(())
3885 }
3886 }
3887
3888 impl ::fidl_next::FromWire<crate::wire::InterruptModes> for InterruptModes {
3889 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InterruptModes, Self> = unsafe {
3890 ::fidl_next::CopyOptimization::enable_if(
3891 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled()
3892 && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
3893 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
3894 .is_enabled(),
3895 )
3896 };
3897
3898 #[inline]
3899 fn from_wire(wire: crate::wire::InterruptModes) -> Self {
3900 Self {
3901 has_legacy: ::fidl_next::FromWire::from_wire(wire.has_legacy),
3902
3903 msi_count: ::fidl_next::FromWire::from_wire(wire.msi_count),
3904
3905 msix_count: ::fidl_next::FromWire::from_wire(wire.msix_count),
3906 }
3907 }
3908 }
3909
3910 impl ::fidl_next::FromWireRef<crate::wire::InterruptModes> for InterruptModes {
3911 #[inline]
3912 fn from_wire_ref(wire: &crate::wire::InterruptModes) -> Self {
3913 Self {
3914 has_legacy: ::fidl_next::FromWireRef::from_wire_ref(&wire.has_legacy),
3915
3916 msi_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msi_count),
3917
3918 msix_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.msix_count),
3919 }
3920 }
3921 }
3922
3923 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3924 #[repr(C)]
3925 pub struct DeviceGetInterruptModesResponse {
3926 pub modes: crate::natural::InterruptModes,
3927 }
3928
3929 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3930 for DeviceGetInterruptModesResponse
3931 where
3932 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3933 {
3934 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3935 Self,
3936 crate::wire::DeviceGetInterruptModesResponse,
3937 > = unsafe {
3938 ::fidl_next::CopyOptimization::enable_if(
3939 true && <crate::natural::InterruptModes as ::fidl_next::Encode<
3940 crate::wire::InterruptModes,
3941 ___E,
3942 >>::COPY_OPTIMIZATION
3943 .is_enabled(),
3944 )
3945 };
3946
3947 #[inline]
3948 fn encode(
3949 self,
3950 encoder_: &mut ___E,
3951 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3952 _: (),
3953 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3954 ::fidl_next::munge! {
3955 let crate::wire::DeviceGetInterruptModesResponse {
3956 modes,
3957
3958 } = out_;
3959 }
3960
3961 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
3962
3963 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3964
3965 Ok(())
3966 }
3967 }
3968
3969 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
3970 for &'a DeviceGetInterruptModesResponse
3971 where
3972 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3973 {
3974 #[inline]
3975 fn encode(
3976 self,
3977 encoder_: &mut ___E,
3978 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
3979 _: (),
3980 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3981 ::fidl_next::munge! {
3982 let crate::wire::DeviceGetInterruptModesResponse {
3983 modes,
3984
3985 } = out_;
3986 }
3987
3988 ::fidl_next::Encode::encode(&self.modes, encoder_, modes, ())?;
3989
3990 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(modes.as_mut_ptr()) };
3991
3992 Ok(())
3993 }
3994 }
3995
3996 unsafe impl<___E>
3997 ::fidl_next::EncodeOption<
3998 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
3999 ___E,
4000 > for DeviceGetInterruptModesResponse
4001 where
4002 ___E: ::fidl_next::Encoder + ?Sized,
4003 DeviceGetInterruptModesResponse:
4004 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
4005 {
4006 #[inline]
4007 fn encode_option(
4008 this: ::core::option::Option<Self>,
4009 encoder: &mut ___E,
4010 out: &mut ::core::mem::MaybeUninit<
4011 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
4012 >,
4013 _: (),
4014 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4015 if let Some(inner) = this {
4016 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4017 ::fidl_next::wire::Box::encode_present(out);
4018 } else {
4019 ::fidl_next::wire::Box::encode_absent(out);
4020 }
4021
4022 Ok(())
4023 }
4024 }
4025
4026 unsafe impl<'a, ___E>
4027 ::fidl_next::EncodeOption<
4028 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
4029 ___E,
4030 > for &'a DeviceGetInterruptModesResponse
4031 where
4032 ___E: ::fidl_next::Encoder + ?Sized,
4033 &'a DeviceGetInterruptModesResponse:
4034 ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>,
4035 {
4036 #[inline]
4037 fn encode_option(
4038 this: ::core::option::Option<Self>,
4039 encoder: &mut ___E,
4040 out: &mut ::core::mem::MaybeUninit<
4041 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetInterruptModesResponse>,
4042 >,
4043 _: (),
4044 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4045 if let Some(inner) = this {
4046 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4047 ::fidl_next::wire::Box::encode_present(out);
4048 } else {
4049 ::fidl_next::wire::Box::encode_absent(out);
4050 }
4051
4052 Ok(())
4053 }
4054 }
4055
4056 impl ::fidl_next::FromWire<crate::wire::DeviceGetInterruptModesResponse>
4057 for DeviceGetInterruptModesResponse
4058 {
4059 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4060 crate::wire::DeviceGetInterruptModesResponse,
4061 Self,
4062 > = unsafe {
4063 ::fidl_next::CopyOptimization::enable_if(
4064 true && <crate::natural::InterruptModes as ::fidl_next::FromWire<
4065 crate::wire::InterruptModes,
4066 >>::COPY_OPTIMIZATION
4067 .is_enabled(),
4068 )
4069 };
4070
4071 #[inline]
4072 fn from_wire(wire: crate::wire::DeviceGetInterruptModesResponse) -> Self {
4073 Self { modes: ::fidl_next::FromWire::from_wire(wire.modes) }
4074 }
4075 }
4076
4077 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetInterruptModesResponse>
4078 for DeviceGetInterruptModesResponse
4079 {
4080 #[inline]
4081 fn from_wire_ref(wire: &crate::wire::DeviceGetInterruptModesResponse) -> Self {
4082 Self { modes: ::fidl_next::FromWireRef::from_wire_ref(&wire.modes) }
4083 }
4084 }
4085
4086 #[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|.\n"]
4087 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4088 #[repr(u8)]
4089 pub enum InterruptMode {
4090 Disabled = 0,
4091 Legacy = 1,
4092 Msi = 2,
4093 MsiX = 3,
4094 }
4095 impl ::core::convert::TryFrom<u8> for InterruptMode {
4096 type Error = ::fidl_next::UnknownStrictEnumMemberError;
4097 fn try_from(
4098 value: u8,
4099 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
4100 match value {
4101 0 => Ok(Self::Disabled),
4102 1 => Ok(Self::Legacy),
4103 2 => Ok(Self::Msi),
4104 3 => Ok(Self::MsiX),
4105
4106 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
4107 }
4108 }
4109 }
4110
4111 impl ::std::convert::From<InterruptMode> for u8 {
4112 fn from(value: InterruptMode) -> Self {
4113 match value {
4114 InterruptMode::Disabled => 0,
4115 InterruptMode::Legacy => 1,
4116 InterruptMode::Msi => 2,
4117 InterruptMode::MsiX => 3,
4118 }
4119 }
4120 }
4121
4122 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for InterruptMode
4123 where
4124 ___E: ?Sized,
4125 {
4126 #[inline]
4127 fn encode(
4128 self,
4129 encoder: &mut ___E,
4130 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
4131 _: (),
4132 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4133 ::fidl_next::Encode::encode(&self, encoder, out, ())
4134 }
4135 }
4136
4137 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::InterruptMode, ___E> for &'a InterruptMode
4138 where
4139 ___E: ?Sized,
4140 {
4141 #[inline]
4142 fn encode(
4143 self,
4144 encoder: &mut ___E,
4145 out: &mut ::core::mem::MaybeUninit<crate::wire::InterruptMode>,
4146 _: (),
4147 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4148 ::fidl_next::munge!(let crate::wire::InterruptMode { value } = out);
4149 let _ = value.write(u8::from(match *self {
4150 InterruptMode::Disabled => 0,
4151
4152 InterruptMode::Legacy => 1,
4153
4154 InterruptMode::Msi => 2,
4155
4156 InterruptMode::MsiX => 3,
4157 }));
4158
4159 Ok(())
4160 }
4161 }
4162
4163 impl ::core::convert::From<crate::wire::InterruptMode> for InterruptMode {
4164 fn from(wire: crate::wire::InterruptMode) -> Self {
4165 match u8::from(wire.value) {
4166 0 => Self::Disabled,
4167
4168 1 => Self::Legacy,
4169
4170 2 => Self::Msi,
4171
4172 3 => Self::MsiX,
4173
4174 _ => unsafe { ::core::hint::unreachable_unchecked() },
4175 }
4176 }
4177 }
4178
4179 impl ::fidl_next::FromWire<crate::wire::InterruptMode> for InterruptMode {
4180 #[inline]
4181 fn from_wire(wire: crate::wire::InterruptMode) -> Self {
4182 Self::from(wire)
4183 }
4184 }
4185
4186 impl ::fidl_next::FromWireRef<crate::wire::InterruptMode> for InterruptMode {
4187 #[inline]
4188 fn from_wire_ref(wire: &crate::wire::InterruptMode) -> Self {
4189 Self::from(*wire)
4190 }
4191 }
4192
4193 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4194 pub struct DeviceSetInterruptModeRequest {
4195 pub mode: crate::natural::InterruptMode,
4196
4197 pub requested_irq_count: u32,
4198 }
4199
4200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
4201 for DeviceSetInterruptModeRequest
4202 where
4203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4204 {
4205 #[inline]
4206 fn encode(
4207 self,
4208 encoder_: &mut ___E,
4209 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
4210 _: (),
4211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4212 ::fidl_next::munge! {
4213 let crate::wire::DeviceSetInterruptModeRequest {
4214 mode,
4215 requested_irq_count,
4216
4217 } = out_;
4218 }
4219
4220 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
4221
4222 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
4223
4224 ::fidl_next::Encode::encode(
4225 self.requested_irq_count,
4226 encoder_,
4227 requested_irq_count,
4228 (),
4229 )?;
4230
4231 let mut _field =
4232 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
4233
4234 Ok(())
4235 }
4236 }
4237
4238 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
4239 for &'a DeviceSetInterruptModeRequest
4240 where
4241 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4242 {
4243 #[inline]
4244 fn encode(
4245 self,
4246 encoder_: &mut ___E,
4247 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
4248 _: (),
4249 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4250 ::fidl_next::munge! {
4251 let crate::wire::DeviceSetInterruptModeRequest {
4252 mode,
4253 requested_irq_count,
4254
4255 } = out_;
4256 }
4257
4258 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
4259
4260 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
4261
4262 ::fidl_next::Encode::encode(
4263 &self.requested_irq_count,
4264 encoder_,
4265 requested_irq_count,
4266 (),
4267 )?;
4268
4269 let mut _field =
4270 unsafe { ::fidl_next::Slot::new_unchecked(requested_irq_count.as_mut_ptr()) };
4271
4272 Ok(())
4273 }
4274 }
4275
4276 unsafe impl<___E>
4277 ::fidl_next::EncodeOption<
4278 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
4279 ___E,
4280 > for DeviceSetInterruptModeRequest
4281 where
4282 ___E: ::fidl_next::Encoder + ?Sized,
4283 DeviceSetInterruptModeRequest:
4284 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
4285 {
4286 #[inline]
4287 fn encode_option(
4288 this: ::core::option::Option<Self>,
4289 encoder: &mut ___E,
4290 out: &mut ::core::mem::MaybeUninit<
4291 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
4292 >,
4293 _: (),
4294 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4295 if let Some(inner) = this {
4296 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4297 ::fidl_next::wire::Box::encode_present(out);
4298 } else {
4299 ::fidl_next::wire::Box::encode_absent(out);
4300 }
4301
4302 Ok(())
4303 }
4304 }
4305
4306 unsafe impl<'a, ___E>
4307 ::fidl_next::EncodeOption<
4308 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
4309 ___E,
4310 > for &'a DeviceSetInterruptModeRequest
4311 where
4312 ___E: ::fidl_next::Encoder + ?Sized,
4313 &'a DeviceSetInterruptModeRequest:
4314 ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>,
4315 {
4316 #[inline]
4317 fn encode_option(
4318 this: ::core::option::Option<Self>,
4319 encoder: &mut ___E,
4320 out: &mut ::core::mem::MaybeUninit<
4321 ::fidl_next::wire::Box<'static, crate::wire::DeviceSetInterruptModeRequest>,
4322 >,
4323 _: (),
4324 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4325 if let Some(inner) = this {
4326 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4327 ::fidl_next::wire::Box::encode_present(out);
4328 } else {
4329 ::fidl_next::wire::Box::encode_absent(out);
4330 }
4331
4332 Ok(())
4333 }
4334 }
4335
4336 impl ::fidl_next::FromWire<crate::wire::DeviceSetInterruptModeRequest>
4337 for DeviceSetInterruptModeRequest
4338 {
4339 #[inline]
4340 fn from_wire(wire: crate::wire::DeviceSetInterruptModeRequest) -> Self {
4341 Self {
4342 mode: ::fidl_next::FromWire::from_wire(wire.mode),
4343
4344 requested_irq_count: ::fidl_next::FromWire::from_wire(wire.requested_irq_count),
4345 }
4346 }
4347 }
4348
4349 impl ::fidl_next::FromWireRef<crate::wire::DeviceSetInterruptModeRequest>
4350 for DeviceSetInterruptModeRequest
4351 {
4352 #[inline]
4353 fn from_wire_ref(wire: &crate::wire::DeviceSetInterruptModeRequest) -> Self {
4354 Self {
4355 mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
4356
4357 requested_irq_count: ::fidl_next::FromWireRef::from_wire_ref(
4358 &wire.requested_irq_count,
4359 ),
4360 }
4361 }
4362 }
4363
4364 pub type DeviceSetInterruptModeResponse = ();
4365
4366 #[doc = " An offset from the beginning of a device\'s PCIe configuration space. [0, 0x800) is valid.\n"]
4367 pub type ExtendedConfigOffset = u16;
4368
4369 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4370 #[repr(C)]
4371 pub struct DeviceReadConfig8Request {
4372 pub offset: u16,
4373 }
4374
4375 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
4376 for DeviceReadConfig8Request
4377 where
4378 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4379 {
4380 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4381 Self,
4382 crate::wire::DeviceReadConfig8Request,
4383 > = unsafe {
4384 ::fidl_next::CopyOptimization::enable_if(
4385 true
4386
4387 && <
4388 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4389 >::COPY_OPTIMIZATION.is_enabled()
4390
4391 )
4392 };
4393
4394 #[inline]
4395 fn encode(
4396 self,
4397 encoder_: &mut ___E,
4398 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
4399 _: (),
4400 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4401 ::fidl_next::munge! {
4402 let crate::wire::DeviceReadConfig8Request {
4403 offset,
4404
4405 } = out_;
4406 }
4407
4408 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4409
4410 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4411
4412 Ok(())
4413 }
4414 }
4415
4416 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
4417 for &'a DeviceReadConfig8Request
4418 where
4419 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4420 {
4421 #[inline]
4422 fn encode(
4423 self,
4424 encoder_: &mut ___E,
4425 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
4426 _: (),
4427 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4428 ::fidl_next::munge! {
4429 let crate::wire::DeviceReadConfig8Request {
4430 offset,
4431
4432 } = out_;
4433 }
4434
4435 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4436
4437 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4438
4439 Ok(())
4440 }
4441 }
4442
4443 unsafe impl<___E>
4444 ::fidl_next::EncodeOption<
4445 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4446 ___E,
4447 > for DeviceReadConfig8Request
4448 where
4449 ___E: ::fidl_next::Encoder + ?Sized,
4450 DeviceReadConfig8Request: ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
4451 {
4452 #[inline]
4453 fn encode_option(
4454 this: ::core::option::Option<Self>,
4455 encoder: &mut ___E,
4456 out: &mut ::core::mem::MaybeUninit<
4457 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4458 >,
4459 _: (),
4460 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4461 if let Some(inner) = this {
4462 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4463 ::fidl_next::wire::Box::encode_present(out);
4464 } else {
4465 ::fidl_next::wire::Box::encode_absent(out);
4466 }
4467
4468 Ok(())
4469 }
4470 }
4471
4472 unsafe impl<'a, ___E>
4473 ::fidl_next::EncodeOption<
4474 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4475 ___E,
4476 > for &'a DeviceReadConfig8Request
4477 where
4478 ___E: ::fidl_next::Encoder + ?Sized,
4479 &'a DeviceReadConfig8Request:
4480 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>,
4481 {
4482 #[inline]
4483 fn encode_option(
4484 this: ::core::option::Option<Self>,
4485 encoder: &mut ___E,
4486 out: &mut ::core::mem::MaybeUninit<
4487 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Request>,
4488 >,
4489 _: (),
4490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4491 if let Some(inner) = this {
4492 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4493 ::fidl_next::wire::Box::encode_present(out);
4494 } else {
4495 ::fidl_next::wire::Box::encode_absent(out);
4496 }
4497
4498 Ok(())
4499 }
4500 }
4501
4502 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
4503 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4504 crate::wire::DeviceReadConfig8Request,
4505 Self,
4506 > = unsafe {
4507 ::fidl_next::CopyOptimization::enable_if(
4508 true
4509 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4510 .is_enabled(),
4511 )
4512 };
4513
4514 #[inline]
4515 fn from_wire(wire: crate::wire::DeviceReadConfig8Request) -> Self {
4516 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4517 }
4518 }
4519
4520 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Request> for DeviceReadConfig8Request {
4521 #[inline]
4522 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Request) -> Self {
4523 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4524 }
4525 }
4526
4527 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4528 #[repr(C)]
4529 pub struct DeviceReadConfig8Response {
4530 pub value: u8,
4531 }
4532
4533 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
4534 for DeviceReadConfig8Response
4535 where
4536 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4537 {
4538 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4539 Self,
4540 crate::wire::DeviceReadConfig8Response,
4541 > = unsafe {
4542 ::fidl_next::CopyOptimization::enable_if(
4543 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled(),
4544 )
4545 };
4546
4547 #[inline]
4548 fn encode(
4549 self,
4550 encoder_: &mut ___E,
4551 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
4552 _: (),
4553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4554 ::fidl_next::munge! {
4555 let crate::wire::DeviceReadConfig8Response {
4556 value,
4557
4558 } = out_;
4559 }
4560
4561 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4562
4563 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4564
4565 Ok(())
4566 }
4567 }
4568
4569 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
4570 for &'a DeviceReadConfig8Response
4571 where
4572 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4573 {
4574 #[inline]
4575 fn encode(
4576 self,
4577 encoder_: &mut ___E,
4578 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
4579 _: (),
4580 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4581 ::fidl_next::munge! {
4582 let crate::wire::DeviceReadConfig8Response {
4583 value,
4584
4585 } = out_;
4586 }
4587
4588 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4589
4590 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4591
4592 Ok(())
4593 }
4594 }
4595
4596 unsafe impl<___E>
4597 ::fidl_next::EncodeOption<
4598 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4599 ___E,
4600 > for DeviceReadConfig8Response
4601 where
4602 ___E: ::fidl_next::Encoder + ?Sized,
4603 DeviceReadConfig8Response:
4604 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4605 {
4606 #[inline]
4607 fn encode_option(
4608 this: ::core::option::Option<Self>,
4609 encoder: &mut ___E,
4610 out: &mut ::core::mem::MaybeUninit<
4611 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4612 >,
4613 _: (),
4614 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4615 if let Some(inner) = this {
4616 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4617 ::fidl_next::wire::Box::encode_present(out);
4618 } else {
4619 ::fidl_next::wire::Box::encode_absent(out);
4620 }
4621
4622 Ok(())
4623 }
4624 }
4625
4626 unsafe impl<'a, ___E>
4627 ::fidl_next::EncodeOption<
4628 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4629 ___E,
4630 > for &'a DeviceReadConfig8Response
4631 where
4632 ___E: ::fidl_next::Encoder + ?Sized,
4633 &'a DeviceReadConfig8Response:
4634 ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>,
4635 {
4636 #[inline]
4637 fn encode_option(
4638 this: ::core::option::Option<Self>,
4639 encoder: &mut ___E,
4640 out: &mut ::core::mem::MaybeUninit<
4641 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig8Response>,
4642 >,
4643 _: (),
4644 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4645 if let Some(inner) = this {
4646 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4647 ::fidl_next::wire::Box::encode_present(out);
4648 } else {
4649 ::fidl_next::wire::Box::encode_absent(out);
4650 }
4651
4652 Ok(())
4653 }
4654 }
4655
4656 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig8Response> for DeviceReadConfig8Response {
4657 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4658 crate::wire::DeviceReadConfig8Response,
4659 Self,
4660 > = unsafe {
4661 ::fidl_next::CopyOptimization::enable_if(
4662 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled(),
4663 )
4664 };
4665
4666 #[inline]
4667 fn from_wire(wire: crate::wire::DeviceReadConfig8Response) -> Self {
4668 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4669 }
4670 }
4671
4672 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig8Response>
4673 for DeviceReadConfig8Response
4674 {
4675 #[inline]
4676 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig8Response) -> Self {
4677 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
4678 }
4679 }
4680
4681 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4682 #[repr(C)]
4683 pub struct DeviceReadConfig16Request {
4684 pub offset: u16,
4685 }
4686
4687 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4688 for DeviceReadConfig16Request
4689 where
4690 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4691 {
4692 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4693 Self,
4694 crate::wire::DeviceReadConfig16Request,
4695 > = unsafe {
4696 ::fidl_next::CopyOptimization::enable_if(
4697 true
4698
4699 && <
4700 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4701 >::COPY_OPTIMIZATION.is_enabled()
4702
4703 )
4704 };
4705
4706 #[inline]
4707 fn encode(
4708 self,
4709 encoder_: &mut ___E,
4710 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4711 _: (),
4712 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4713 ::fidl_next::munge! {
4714 let crate::wire::DeviceReadConfig16Request {
4715 offset,
4716
4717 } = out_;
4718 }
4719
4720 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4721
4722 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4723
4724 Ok(())
4725 }
4726 }
4727
4728 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
4729 for &'a DeviceReadConfig16Request
4730 where
4731 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4732 {
4733 #[inline]
4734 fn encode(
4735 self,
4736 encoder_: &mut ___E,
4737 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
4738 _: (),
4739 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4740 ::fidl_next::munge! {
4741 let crate::wire::DeviceReadConfig16Request {
4742 offset,
4743
4744 } = out_;
4745 }
4746
4747 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4748
4749 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4750
4751 Ok(())
4752 }
4753 }
4754
4755 unsafe impl<___E>
4756 ::fidl_next::EncodeOption<
4757 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4758 ___E,
4759 > for DeviceReadConfig16Request
4760 where
4761 ___E: ::fidl_next::Encoder + ?Sized,
4762 DeviceReadConfig16Request:
4763 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4764 {
4765 #[inline]
4766 fn encode_option(
4767 this: ::core::option::Option<Self>,
4768 encoder: &mut ___E,
4769 out: &mut ::core::mem::MaybeUninit<
4770 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4771 >,
4772 _: (),
4773 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4774 if let Some(inner) = this {
4775 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4776 ::fidl_next::wire::Box::encode_present(out);
4777 } else {
4778 ::fidl_next::wire::Box::encode_absent(out);
4779 }
4780
4781 Ok(())
4782 }
4783 }
4784
4785 unsafe impl<'a, ___E>
4786 ::fidl_next::EncodeOption<
4787 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4788 ___E,
4789 > for &'a DeviceReadConfig16Request
4790 where
4791 ___E: ::fidl_next::Encoder + ?Sized,
4792 &'a DeviceReadConfig16Request:
4793 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>,
4794 {
4795 #[inline]
4796 fn encode_option(
4797 this: ::core::option::Option<Self>,
4798 encoder: &mut ___E,
4799 out: &mut ::core::mem::MaybeUninit<
4800 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Request>,
4801 >,
4802 _: (),
4803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4804 if let Some(inner) = this {
4805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4806 ::fidl_next::wire::Box::encode_present(out);
4807 } else {
4808 ::fidl_next::wire::Box::encode_absent(out);
4809 }
4810
4811 Ok(())
4812 }
4813 }
4814
4815 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Request> for DeviceReadConfig16Request {
4816 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4817 crate::wire::DeviceReadConfig16Request,
4818 Self,
4819 > = unsafe {
4820 ::fidl_next::CopyOptimization::enable_if(
4821 true
4822 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4823 .is_enabled(),
4824 )
4825 };
4826
4827 #[inline]
4828 fn from_wire(wire: crate::wire::DeviceReadConfig16Request) -> Self {
4829 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
4830 }
4831 }
4832
4833 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Request>
4834 for DeviceReadConfig16Request
4835 {
4836 #[inline]
4837 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Request) -> Self {
4838 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
4839 }
4840 }
4841
4842 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4843 #[repr(C)]
4844 pub struct DeviceReadConfig16Response {
4845 pub value: u16,
4846 }
4847
4848 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4849 for DeviceReadConfig16Response
4850 where
4851 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4852 {
4853 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4854 Self,
4855 crate::wire::DeviceReadConfig16Response,
4856 > = unsafe {
4857 ::fidl_next::CopyOptimization::enable_if(
4858 true
4859
4860 && <
4861 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
4862 >::COPY_OPTIMIZATION.is_enabled()
4863
4864 )
4865 };
4866
4867 #[inline]
4868 fn encode(
4869 self,
4870 encoder_: &mut ___E,
4871 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4872 _: (),
4873 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4874 ::fidl_next::munge! {
4875 let crate::wire::DeviceReadConfig16Response {
4876 value,
4877
4878 } = out_;
4879 }
4880
4881 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4882
4883 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4884
4885 Ok(())
4886 }
4887 }
4888
4889 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
4890 for &'a DeviceReadConfig16Response
4891 where
4892 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4893 {
4894 #[inline]
4895 fn encode(
4896 self,
4897 encoder_: &mut ___E,
4898 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
4899 _: (),
4900 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4901 ::fidl_next::munge! {
4902 let crate::wire::DeviceReadConfig16Response {
4903 value,
4904
4905 } = out_;
4906 }
4907
4908 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
4909
4910 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
4911
4912 Ok(())
4913 }
4914 }
4915
4916 unsafe impl<___E>
4917 ::fidl_next::EncodeOption<
4918 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4919 ___E,
4920 > for DeviceReadConfig16Response
4921 where
4922 ___E: ::fidl_next::Encoder + ?Sized,
4923 DeviceReadConfig16Response:
4924 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4925 {
4926 #[inline]
4927 fn encode_option(
4928 this: ::core::option::Option<Self>,
4929 encoder: &mut ___E,
4930 out: &mut ::core::mem::MaybeUninit<
4931 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4932 >,
4933 _: (),
4934 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4935 if let Some(inner) = this {
4936 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4937 ::fidl_next::wire::Box::encode_present(out);
4938 } else {
4939 ::fidl_next::wire::Box::encode_absent(out);
4940 }
4941
4942 Ok(())
4943 }
4944 }
4945
4946 unsafe impl<'a, ___E>
4947 ::fidl_next::EncodeOption<
4948 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4949 ___E,
4950 > for &'a DeviceReadConfig16Response
4951 where
4952 ___E: ::fidl_next::Encoder + ?Sized,
4953 &'a DeviceReadConfig16Response:
4954 ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>,
4955 {
4956 #[inline]
4957 fn encode_option(
4958 this: ::core::option::Option<Self>,
4959 encoder: &mut ___E,
4960 out: &mut ::core::mem::MaybeUninit<
4961 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig16Response>,
4962 >,
4963 _: (),
4964 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4965 if let Some(inner) = this {
4966 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4967 ::fidl_next::wire::Box::encode_present(out);
4968 } else {
4969 ::fidl_next::wire::Box::encode_absent(out);
4970 }
4971
4972 Ok(())
4973 }
4974 }
4975
4976 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig16Response> for DeviceReadConfig16Response {
4977 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4978 crate::wire::DeviceReadConfig16Response,
4979 Self,
4980 > = unsafe {
4981 ::fidl_next::CopyOptimization::enable_if(
4982 true
4983 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
4984 .is_enabled(),
4985 )
4986 };
4987
4988 #[inline]
4989 fn from_wire(wire: crate::wire::DeviceReadConfig16Response) -> Self {
4990 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
4991 }
4992 }
4993
4994 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig16Response>
4995 for DeviceReadConfig16Response
4996 {
4997 #[inline]
4998 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig16Response) -> Self {
4999 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
5000 }
5001 }
5002
5003 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5004 #[repr(C)]
5005 pub struct DeviceReadConfig32Request {
5006 pub offset: u16,
5007 }
5008
5009 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
5010 for DeviceReadConfig32Request
5011 where
5012 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5013 {
5014 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5015 Self,
5016 crate::wire::DeviceReadConfig32Request,
5017 > = unsafe {
5018 ::fidl_next::CopyOptimization::enable_if(
5019 true
5020
5021 && <
5022 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
5023 >::COPY_OPTIMIZATION.is_enabled()
5024
5025 )
5026 };
5027
5028 #[inline]
5029 fn encode(
5030 self,
5031 encoder_: &mut ___E,
5032 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
5033 _: (),
5034 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5035 ::fidl_next::munge! {
5036 let crate::wire::DeviceReadConfig32Request {
5037 offset,
5038
5039 } = out_;
5040 }
5041
5042 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5043
5044 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5045
5046 Ok(())
5047 }
5048 }
5049
5050 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
5051 for &'a DeviceReadConfig32Request
5052 where
5053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5054 {
5055 #[inline]
5056 fn encode(
5057 self,
5058 encoder_: &mut ___E,
5059 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
5060 _: (),
5061 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5062 ::fidl_next::munge! {
5063 let crate::wire::DeviceReadConfig32Request {
5064 offset,
5065
5066 } = out_;
5067 }
5068
5069 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5070
5071 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5072
5073 Ok(())
5074 }
5075 }
5076
5077 unsafe impl<___E>
5078 ::fidl_next::EncodeOption<
5079 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
5080 ___E,
5081 > for DeviceReadConfig32Request
5082 where
5083 ___E: ::fidl_next::Encoder + ?Sized,
5084 DeviceReadConfig32Request:
5085 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
5086 {
5087 #[inline]
5088 fn encode_option(
5089 this: ::core::option::Option<Self>,
5090 encoder: &mut ___E,
5091 out: &mut ::core::mem::MaybeUninit<
5092 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
5093 >,
5094 _: (),
5095 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5096 if let Some(inner) = this {
5097 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5098 ::fidl_next::wire::Box::encode_present(out);
5099 } else {
5100 ::fidl_next::wire::Box::encode_absent(out);
5101 }
5102
5103 Ok(())
5104 }
5105 }
5106
5107 unsafe impl<'a, ___E>
5108 ::fidl_next::EncodeOption<
5109 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
5110 ___E,
5111 > for &'a DeviceReadConfig32Request
5112 where
5113 ___E: ::fidl_next::Encoder + ?Sized,
5114 &'a DeviceReadConfig32Request:
5115 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>,
5116 {
5117 #[inline]
5118 fn encode_option(
5119 this: ::core::option::Option<Self>,
5120 encoder: &mut ___E,
5121 out: &mut ::core::mem::MaybeUninit<
5122 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Request>,
5123 >,
5124 _: (),
5125 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5126 if let Some(inner) = this {
5127 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5128 ::fidl_next::wire::Box::encode_present(out);
5129 } else {
5130 ::fidl_next::wire::Box::encode_absent(out);
5131 }
5132
5133 Ok(())
5134 }
5135 }
5136
5137 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Request> for DeviceReadConfig32Request {
5138 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5139 crate::wire::DeviceReadConfig32Request,
5140 Self,
5141 > = unsafe {
5142 ::fidl_next::CopyOptimization::enable_if(
5143 true
5144 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5145 .is_enabled(),
5146 )
5147 };
5148
5149 #[inline]
5150 fn from_wire(wire: crate::wire::DeviceReadConfig32Request) -> Self {
5151 Self { offset: ::fidl_next::FromWire::from_wire(wire.offset) }
5152 }
5153 }
5154
5155 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Request>
5156 for DeviceReadConfig32Request
5157 {
5158 #[inline]
5159 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Request) -> Self {
5160 Self { offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset) }
5161 }
5162 }
5163
5164 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5165 #[repr(C)]
5166 pub struct DeviceReadConfig32Response {
5167 pub value: u32,
5168 }
5169
5170 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
5171 for DeviceReadConfig32Response
5172 where
5173 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5174 {
5175 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5176 Self,
5177 crate::wire::DeviceReadConfig32Response,
5178 > = unsafe {
5179 ::fidl_next::CopyOptimization::enable_if(
5180 true
5181
5182 && <
5183 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
5184 >::COPY_OPTIMIZATION.is_enabled()
5185
5186 )
5187 };
5188
5189 #[inline]
5190 fn encode(
5191 self,
5192 encoder_: &mut ___E,
5193 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
5194 _: (),
5195 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5196 ::fidl_next::munge! {
5197 let crate::wire::DeviceReadConfig32Response {
5198 value,
5199
5200 } = out_;
5201 }
5202
5203 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5204
5205 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5206
5207 Ok(())
5208 }
5209 }
5210
5211 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
5212 for &'a DeviceReadConfig32Response
5213 where
5214 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5215 {
5216 #[inline]
5217 fn encode(
5218 self,
5219 encoder_: &mut ___E,
5220 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
5221 _: (),
5222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5223 ::fidl_next::munge! {
5224 let crate::wire::DeviceReadConfig32Response {
5225 value,
5226
5227 } = out_;
5228 }
5229
5230 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5231
5232 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5233
5234 Ok(())
5235 }
5236 }
5237
5238 unsafe impl<___E>
5239 ::fidl_next::EncodeOption<
5240 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
5241 ___E,
5242 > for DeviceReadConfig32Response
5243 where
5244 ___E: ::fidl_next::Encoder + ?Sized,
5245 DeviceReadConfig32Response:
5246 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
5247 {
5248 #[inline]
5249 fn encode_option(
5250 this: ::core::option::Option<Self>,
5251 encoder: &mut ___E,
5252 out: &mut ::core::mem::MaybeUninit<
5253 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
5254 >,
5255 _: (),
5256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5257 if let Some(inner) = this {
5258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5259 ::fidl_next::wire::Box::encode_present(out);
5260 } else {
5261 ::fidl_next::wire::Box::encode_absent(out);
5262 }
5263
5264 Ok(())
5265 }
5266 }
5267
5268 unsafe impl<'a, ___E>
5269 ::fidl_next::EncodeOption<
5270 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
5271 ___E,
5272 > for &'a DeviceReadConfig32Response
5273 where
5274 ___E: ::fidl_next::Encoder + ?Sized,
5275 &'a DeviceReadConfig32Response:
5276 ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>,
5277 {
5278 #[inline]
5279 fn encode_option(
5280 this: ::core::option::Option<Self>,
5281 encoder: &mut ___E,
5282 out: &mut ::core::mem::MaybeUninit<
5283 ::fidl_next::wire::Box<'static, crate::wire::DeviceReadConfig32Response>,
5284 >,
5285 _: (),
5286 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5287 if let Some(inner) = this {
5288 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5289 ::fidl_next::wire::Box::encode_present(out);
5290 } else {
5291 ::fidl_next::wire::Box::encode_absent(out);
5292 }
5293
5294 Ok(())
5295 }
5296 }
5297
5298 impl ::fidl_next::FromWire<crate::wire::DeviceReadConfig32Response> for DeviceReadConfig32Response {
5299 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5300 crate::wire::DeviceReadConfig32Response,
5301 Self,
5302 > = unsafe {
5303 ::fidl_next::CopyOptimization::enable_if(
5304 true
5305 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
5306 .is_enabled(),
5307 )
5308 };
5309
5310 #[inline]
5311 fn from_wire(wire: crate::wire::DeviceReadConfig32Response) -> Self {
5312 Self { value: ::fidl_next::FromWire::from_wire(wire.value) }
5313 }
5314 }
5315
5316 impl ::fidl_next::FromWireRef<crate::wire::DeviceReadConfig32Response>
5317 for DeviceReadConfig32Response
5318 {
5319 #[inline]
5320 fn from_wire_ref(wire: &crate::wire::DeviceReadConfig32Response) -> Self {
5321 Self { value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value) }
5322 }
5323 }
5324
5325 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5326 pub struct DeviceWriteConfig8Request {
5327 pub offset: u16,
5328
5329 pub value: u8,
5330 }
5331
5332 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
5333 for DeviceWriteConfig8Request
5334 where
5335 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5336 {
5337 #[inline]
5338 fn encode(
5339 self,
5340 encoder_: &mut ___E,
5341 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
5342 _: (),
5343 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5344 ::fidl_next::munge! {
5345 let crate::wire::DeviceWriteConfig8Request {
5346 offset,
5347 value,
5348
5349 } = out_;
5350 }
5351
5352 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5353
5354 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5355
5356 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5357
5358 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5359
5360 Ok(())
5361 }
5362 }
5363
5364 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
5365 for &'a DeviceWriteConfig8Request
5366 where
5367 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5368 {
5369 #[inline]
5370 fn encode(
5371 self,
5372 encoder_: &mut ___E,
5373 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
5374 _: (),
5375 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5376 ::fidl_next::munge! {
5377 let crate::wire::DeviceWriteConfig8Request {
5378 offset,
5379 value,
5380
5381 } = out_;
5382 }
5383
5384 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5385
5386 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5387
5388 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5389
5390 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5391
5392 Ok(())
5393 }
5394 }
5395
5396 unsafe impl<___E>
5397 ::fidl_next::EncodeOption<
5398 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
5399 ___E,
5400 > for DeviceWriteConfig8Request
5401 where
5402 ___E: ::fidl_next::Encoder + ?Sized,
5403 DeviceWriteConfig8Request:
5404 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
5405 {
5406 #[inline]
5407 fn encode_option(
5408 this: ::core::option::Option<Self>,
5409 encoder: &mut ___E,
5410 out: &mut ::core::mem::MaybeUninit<
5411 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
5412 >,
5413 _: (),
5414 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5415 if let Some(inner) = this {
5416 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5417 ::fidl_next::wire::Box::encode_present(out);
5418 } else {
5419 ::fidl_next::wire::Box::encode_absent(out);
5420 }
5421
5422 Ok(())
5423 }
5424 }
5425
5426 unsafe impl<'a, ___E>
5427 ::fidl_next::EncodeOption<
5428 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
5429 ___E,
5430 > for &'a DeviceWriteConfig8Request
5431 where
5432 ___E: ::fidl_next::Encoder + ?Sized,
5433 &'a DeviceWriteConfig8Request:
5434 ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>,
5435 {
5436 #[inline]
5437 fn encode_option(
5438 this: ::core::option::Option<Self>,
5439 encoder: &mut ___E,
5440 out: &mut ::core::mem::MaybeUninit<
5441 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig8Request>,
5442 >,
5443 _: (),
5444 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5445 if let Some(inner) = this {
5446 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5447 ::fidl_next::wire::Box::encode_present(out);
5448 } else {
5449 ::fidl_next::wire::Box::encode_absent(out);
5450 }
5451
5452 Ok(())
5453 }
5454 }
5455
5456 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig8Request> for DeviceWriteConfig8Request {
5457 #[inline]
5458 fn from_wire(wire: crate::wire::DeviceWriteConfig8Request) -> Self {
5459 Self {
5460 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5461
5462 value: ::fidl_next::FromWire::from_wire(wire.value),
5463 }
5464 }
5465 }
5466
5467 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig8Request>
5468 for DeviceWriteConfig8Request
5469 {
5470 #[inline]
5471 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig8Request) -> Self {
5472 Self {
5473 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5474
5475 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5476 }
5477 }
5478 }
5479
5480 pub type DeviceWriteConfig8Response = ();
5481
5482 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5483 #[repr(C)]
5484 pub struct DeviceWriteConfig16Request {
5485 pub offset: u16,
5486
5487 pub value: u16,
5488 }
5489
5490 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
5491 for DeviceWriteConfig16Request
5492 where
5493 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5494 {
5495 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5496 Self,
5497 crate::wire::DeviceWriteConfig16Request,
5498 > = unsafe {
5499 ::fidl_next::CopyOptimization::enable_if(
5500 true
5501
5502 && <
5503 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
5504 >::COPY_OPTIMIZATION.is_enabled()
5505
5506 && <
5507 u16 as ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>
5508 >::COPY_OPTIMIZATION.is_enabled()
5509
5510 )
5511 };
5512
5513 #[inline]
5514 fn encode(
5515 self,
5516 encoder_: &mut ___E,
5517 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
5518 _: (),
5519 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5520 ::fidl_next::munge! {
5521 let crate::wire::DeviceWriteConfig16Request {
5522 offset,
5523 value,
5524
5525 } = out_;
5526 }
5527
5528 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5529
5530 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5531
5532 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5533
5534 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5535
5536 Ok(())
5537 }
5538 }
5539
5540 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
5541 for &'a DeviceWriteConfig16Request
5542 where
5543 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5544 {
5545 #[inline]
5546 fn encode(
5547 self,
5548 encoder_: &mut ___E,
5549 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
5550 _: (),
5551 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5552 ::fidl_next::munge! {
5553 let crate::wire::DeviceWriteConfig16Request {
5554 offset,
5555 value,
5556
5557 } = out_;
5558 }
5559
5560 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5561
5562 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5563
5564 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5565
5566 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5567
5568 Ok(())
5569 }
5570 }
5571
5572 unsafe impl<___E>
5573 ::fidl_next::EncodeOption<
5574 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5575 ___E,
5576 > for DeviceWriteConfig16Request
5577 where
5578 ___E: ::fidl_next::Encoder + ?Sized,
5579 DeviceWriteConfig16Request:
5580 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5581 {
5582 #[inline]
5583 fn encode_option(
5584 this: ::core::option::Option<Self>,
5585 encoder: &mut ___E,
5586 out: &mut ::core::mem::MaybeUninit<
5587 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5588 >,
5589 _: (),
5590 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5591 if let Some(inner) = this {
5592 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5593 ::fidl_next::wire::Box::encode_present(out);
5594 } else {
5595 ::fidl_next::wire::Box::encode_absent(out);
5596 }
5597
5598 Ok(())
5599 }
5600 }
5601
5602 unsafe impl<'a, ___E>
5603 ::fidl_next::EncodeOption<
5604 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5605 ___E,
5606 > for &'a DeviceWriteConfig16Request
5607 where
5608 ___E: ::fidl_next::Encoder + ?Sized,
5609 &'a DeviceWriteConfig16Request:
5610 ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>,
5611 {
5612 #[inline]
5613 fn encode_option(
5614 this: ::core::option::Option<Self>,
5615 encoder: &mut ___E,
5616 out: &mut ::core::mem::MaybeUninit<
5617 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig16Request>,
5618 >,
5619 _: (),
5620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5621 if let Some(inner) = this {
5622 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5623 ::fidl_next::wire::Box::encode_present(out);
5624 } else {
5625 ::fidl_next::wire::Box::encode_absent(out);
5626 }
5627
5628 Ok(())
5629 }
5630 }
5631
5632 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig16Request> for DeviceWriteConfig16Request {
5633 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5634 crate::wire::DeviceWriteConfig16Request,
5635 Self,
5636 > = unsafe {
5637 ::fidl_next::CopyOptimization::enable_if(
5638 true
5639 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5640 .is_enabled()
5641 && <u16 as ::fidl_next::FromWire<::fidl_next::wire::Uint16>>::COPY_OPTIMIZATION
5642 .is_enabled(),
5643 )
5644 };
5645
5646 #[inline]
5647 fn from_wire(wire: crate::wire::DeviceWriteConfig16Request) -> Self {
5648 Self {
5649 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5650
5651 value: ::fidl_next::FromWire::from_wire(wire.value),
5652 }
5653 }
5654 }
5655
5656 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig16Request>
5657 for DeviceWriteConfig16Request
5658 {
5659 #[inline]
5660 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig16Request) -> Self {
5661 Self {
5662 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5663
5664 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5665 }
5666 }
5667 }
5668
5669 pub type DeviceWriteConfig16Response = ();
5670
5671 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5672 pub struct DeviceWriteConfig32Request {
5673 pub offset: u16,
5674
5675 pub value: u32,
5676 }
5677
5678 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5679 for DeviceWriteConfig32Request
5680 where
5681 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5682 {
5683 #[inline]
5684 fn encode(
5685 self,
5686 encoder_: &mut ___E,
5687 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5688 _: (),
5689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5690 ::fidl_next::munge! {
5691 let crate::wire::DeviceWriteConfig32Request {
5692 offset,
5693 value,
5694
5695 } = out_;
5696 }
5697
5698 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5699
5700 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5701
5702 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5703
5704 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5705
5706 Ok(())
5707 }
5708 }
5709
5710 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
5711 for &'a DeviceWriteConfig32Request
5712 where
5713 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5714 {
5715 #[inline]
5716 fn encode(
5717 self,
5718 encoder_: &mut ___E,
5719 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
5720 _: (),
5721 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5722 ::fidl_next::munge! {
5723 let crate::wire::DeviceWriteConfig32Request {
5724 offset,
5725 value,
5726
5727 } = out_;
5728 }
5729
5730 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
5731
5732 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
5733
5734 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5735
5736 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
5737
5738 Ok(())
5739 }
5740 }
5741
5742 unsafe impl<___E>
5743 ::fidl_next::EncodeOption<
5744 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5745 ___E,
5746 > for DeviceWriteConfig32Request
5747 where
5748 ___E: ::fidl_next::Encoder + ?Sized,
5749 DeviceWriteConfig32Request:
5750 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5751 {
5752 #[inline]
5753 fn encode_option(
5754 this: ::core::option::Option<Self>,
5755 encoder: &mut ___E,
5756 out: &mut ::core::mem::MaybeUninit<
5757 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5758 >,
5759 _: (),
5760 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5761 if let Some(inner) = this {
5762 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5763 ::fidl_next::wire::Box::encode_present(out);
5764 } else {
5765 ::fidl_next::wire::Box::encode_absent(out);
5766 }
5767
5768 Ok(())
5769 }
5770 }
5771
5772 unsafe impl<'a, ___E>
5773 ::fidl_next::EncodeOption<
5774 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5775 ___E,
5776 > for &'a DeviceWriteConfig32Request
5777 where
5778 ___E: ::fidl_next::Encoder + ?Sized,
5779 &'a DeviceWriteConfig32Request:
5780 ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>,
5781 {
5782 #[inline]
5783 fn encode_option(
5784 this: ::core::option::Option<Self>,
5785 encoder: &mut ___E,
5786 out: &mut ::core::mem::MaybeUninit<
5787 ::fidl_next::wire::Box<'static, crate::wire::DeviceWriteConfig32Request>,
5788 >,
5789 _: (),
5790 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5791 if let Some(inner) = this {
5792 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5793 ::fidl_next::wire::Box::encode_present(out);
5794 } else {
5795 ::fidl_next::wire::Box::encode_absent(out);
5796 }
5797
5798 Ok(())
5799 }
5800 }
5801
5802 impl ::fidl_next::FromWire<crate::wire::DeviceWriteConfig32Request> for DeviceWriteConfig32Request {
5803 #[inline]
5804 fn from_wire(wire: crate::wire::DeviceWriteConfig32Request) -> Self {
5805 Self {
5806 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5807
5808 value: ::fidl_next::FromWire::from_wire(wire.value),
5809 }
5810 }
5811 }
5812
5813 impl ::fidl_next::FromWireRef<crate::wire::DeviceWriteConfig32Request>
5814 for DeviceWriteConfig32Request
5815 {
5816 #[inline]
5817 fn from_wire_ref(wire: &crate::wire::DeviceWriteConfig32Request) -> Self {
5818 Self {
5819 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5820
5821 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
5822 }
5823 }
5824 }
5825
5826 pub type DeviceWriteConfig32Response = ();
5827
5828 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5829 #[repr(C)]
5830 pub struct DeviceGetCapabilitiesRequest {
5831 pub id: crate::natural::CapabilityId,
5832 }
5833
5834 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5835 for DeviceGetCapabilitiesRequest
5836 where
5837 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5838 {
5839 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5840 Self,
5841 crate::wire::DeviceGetCapabilitiesRequest,
5842 > = unsafe {
5843 ::fidl_next::CopyOptimization::enable_if(
5844 true && <crate::natural::CapabilityId as ::fidl_next::Encode<
5845 crate::wire::CapabilityId,
5846 ___E,
5847 >>::COPY_OPTIMIZATION
5848 .is_enabled(),
5849 )
5850 };
5851
5852 #[inline]
5853 fn encode(
5854 self,
5855 encoder_: &mut ___E,
5856 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5857 _: (),
5858 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5859 ::fidl_next::munge! {
5860 let crate::wire::DeviceGetCapabilitiesRequest {
5861 id,
5862
5863 } = out_;
5864 }
5865
5866 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5867
5868 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5869
5870 Ok(())
5871 }
5872 }
5873
5874 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
5875 for &'a DeviceGetCapabilitiesRequest
5876 where
5877 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5878 {
5879 #[inline]
5880 fn encode(
5881 self,
5882 encoder_: &mut ___E,
5883 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
5884 _: (),
5885 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5886 ::fidl_next::munge! {
5887 let crate::wire::DeviceGetCapabilitiesRequest {
5888 id,
5889
5890 } = out_;
5891 }
5892
5893 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
5894
5895 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5896
5897 Ok(())
5898 }
5899 }
5900
5901 unsafe impl<___E>
5902 ::fidl_next::EncodeOption<
5903 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5904 ___E,
5905 > for DeviceGetCapabilitiesRequest
5906 where
5907 ___E: ::fidl_next::Encoder + ?Sized,
5908 DeviceGetCapabilitiesRequest:
5909 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5910 {
5911 #[inline]
5912 fn encode_option(
5913 this: ::core::option::Option<Self>,
5914 encoder: &mut ___E,
5915 out: &mut ::core::mem::MaybeUninit<
5916 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5917 >,
5918 _: (),
5919 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5920 if let Some(inner) = this {
5921 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5922 ::fidl_next::wire::Box::encode_present(out);
5923 } else {
5924 ::fidl_next::wire::Box::encode_absent(out);
5925 }
5926
5927 Ok(())
5928 }
5929 }
5930
5931 unsafe impl<'a, ___E>
5932 ::fidl_next::EncodeOption<
5933 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5934 ___E,
5935 > for &'a DeviceGetCapabilitiesRequest
5936 where
5937 ___E: ::fidl_next::Encoder + ?Sized,
5938 &'a DeviceGetCapabilitiesRequest:
5939 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>,
5940 {
5941 #[inline]
5942 fn encode_option(
5943 this: ::core::option::Option<Self>,
5944 encoder: &mut ___E,
5945 out: &mut ::core::mem::MaybeUninit<
5946 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesRequest>,
5947 >,
5948 _: (),
5949 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5950 if let Some(inner) = this {
5951 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5952 ::fidl_next::wire::Box::encode_present(out);
5953 } else {
5954 ::fidl_next::wire::Box::encode_absent(out);
5955 }
5956
5957 Ok(())
5958 }
5959 }
5960
5961 impl ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesRequest>
5962 for DeviceGetCapabilitiesRequest
5963 {
5964 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5965 crate::wire::DeviceGetCapabilitiesRequest,
5966 Self,
5967 > = unsafe {
5968 ::fidl_next::CopyOptimization::enable_if(
5969 true && <crate::natural::CapabilityId as ::fidl_next::FromWire<
5970 crate::wire::CapabilityId,
5971 >>::COPY_OPTIMIZATION
5972 .is_enabled(),
5973 )
5974 };
5975
5976 #[inline]
5977 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5978 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
5979 }
5980 }
5981
5982 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesRequest>
5983 for DeviceGetCapabilitiesRequest
5984 {
5985 #[inline]
5986 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesRequest) -> Self {
5987 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
5988 }
5989 }
5990
5991 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5992 pub struct DeviceGetCapabilitiesResponse {
5993 pub offsets: ::std::vec::Vec<u8>,
5994 }
5995
5996 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
5997 for DeviceGetCapabilitiesResponse
5998 where
5999 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6000 ___E: ::fidl_next::Encoder,
6001 {
6002 #[inline]
6003 fn encode(
6004 self,
6005 encoder_: &mut ___E,
6006 out_: &mut ::core::mem::MaybeUninit<
6007 crate::wire::DeviceGetCapabilitiesResponse<'static>,
6008 >,
6009 _: (),
6010 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6011 ::fidl_next::munge! {
6012 let crate::wire::DeviceGetCapabilitiesResponse {
6013 offsets,
6014
6015 } = out_;
6016 }
6017
6018 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
6019
6020 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6021 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6022
6023 Ok(())
6024 }
6025 }
6026
6027 unsafe impl<'a, ___E>
6028 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
6029 for &'a DeviceGetCapabilitiesResponse
6030 where
6031 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6032 ___E: ::fidl_next::Encoder,
6033 {
6034 #[inline]
6035 fn encode(
6036 self,
6037 encoder_: &mut ___E,
6038 out_: &mut ::core::mem::MaybeUninit<
6039 crate::wire::DeviceGetCapabilitiesResponse<'static>,
6040 >,
6041 _: (),
6042 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6043 ::fidl_next::munge! {
6044 let crate::wire::DeviceGetCapabilitiesResponse {
6045 offsets,
6046
6047 } = out_;
6048 }
6049
6050 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
6051
6052 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6053 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6054
6055 Ok(())
6056 }
6057 }
6058
6059 unsafe impl<___E>
6060 ::fidl_next::EncodeOption<
6061 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
6062 ___E,
6063 > for DeviceGetCapabilitiesResponse
6064 where
6065 ___E: ::fidl_next::Encoder + ?Sized,
6066 DeviceGetCapabilitiesResponse:
6067 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
6068 {
6069 #[inline]
6070 fn encode_option(
6071 this: ::core::option::Option<Self>,
6072 encoder: &mut ___E,
6073 out: &mut ::core::mem::MaybeUninit<
6074 ::fidl_next::wire::Box<
6075 'static,
6076 crate::wire::DeviceGetCapabilitiesResponse<'static>,
6077 >,
6078 >,
6079 _: (),
6080 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6081 if let Some(inner) = this {
6082 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6083 ::fidl_next::wire::Box::encode_present(out);
6084 } else {
6085 ::fidl_next::wire::Box::encode_absent(out);
6086 }
6087
6088 Ok(())
6089 }
6090 }
6091
6092 unsafe impl<'a, ___E>
6093 ::fidl_next::EncodeOption<
6094 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetCapabilitiesResponse<'static>>,
6095 ___E,
6096 > for &'a DeviceGetCapabilitiesResponse
6097 where
6098 ___E: ::fidl_next::Encoder + ?Sized,
6099 &'a DeviceGetCapabilitiesResponse:
6100 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>,
6101 {
6102 #[inline]
6103 fn encode_option(
6104 this: ::core::option::Option<Self>,
6105 encoder: &mut ___E,
6106 out: &mut ::core::mem::MaybeUninit<
6107 ::fidl_next::wire::Box<
6108 'static,
6109 crate::wire::DeviceGetCapabilitiesResponse<'static>,
6110 >,
6111 >,
6112 _: (),
6113 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6114 if let Some(inner) = this {
6115 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6116 ::fidl_next::wire::Box::encode_present(out);
6117 } else {
6118 ::fidl_next::wire::Box::encode_absent(out);
6119 }
6120
6121 Ok(())
6122 }
6123 }
6124
6125 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetCapabilitiesResponse<'de>>
6126 for DeviceGetCapabilitiesResponse
6127 {
6128 #[inline]
6129 fn from_wire(wire: crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
6130 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
6131 }
6132 }
6133
6134 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetCapabilitiesResponse<'de>>
6135 for DeviceGetCapabilitiesResponse
6136 {
6137 #[inline]
6138 fn from_wire_ref(wire: &crate::wire::DeviceGetCapabilitiesResponse<'de>) -> Self {
6139 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
6140 }
6141 }
6142
6143 #[doc = " PCI Extended Capability IDs.\n PCIe Base Specification rev4, chapter 7.6.\n"]
6144 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6145 #[repr(u16)]
6146 pub enum ExtendedCapabilityId {
6147 Null = 0,
6148 AdvancedErrorReporting = 1,
6149 VirtualChannelNoMfvc = 2,
6150 DeviceSerialNumber = 3,
6151 PowerBudgeting = 4,
6152 RootComplexLinkDeclaration = 5,
6153 RootComplexInternalLinkControl = 6,
6154 RootComplexEventCollectorEndpointAssociation = 7,
6155 MultiFunctionVirtualChannel = 8,
6156 VirtualChannel = 9,
6157 Rcrb = 10,
6158 Vendor = 11,
6159 Cac = 12,
6160 Acs = 13,
6161 Ari = 14,
6162 Ats = 15,
6163 SrIov = 16,
6164 MrIov = 17,
6165 Multicast = 18,
6166 Pri = 19,
6167 EnhancedAllocation = 20,
6168 ResizableBar = 21,
6169 DynamicPowerAllocation = 22,
6170 Tph = 23,
6171 LatencyToleranceReporting = 24,
6172 SecondaryPciExpress = 25,
6173 Pmux = 26,
6174 Pasid = 27,
6175 Lnr = 28,
6176 Dpc = 29,
6177 L1PmSubstates = 30,
6178 PrecisionTimeMeasurement = 31,
6179 Mpcie = 32,
6180 FrsQueueing = 33,
6181 ReadinessTimeReporting = 34,
6182 DesignatedVendor = 35,
6183 VfResizableBar = 36,
6184 DataLinkFeature = 37,
6185 PhysicalLayer16 = 38,
6186 LaneMarginingAtReceiver = 39,
6187 HierarchyId = 40,
6188 NativePcieEnclosure = 41,
6189 PhysicalLayer32 = 42,
6190 AlternateProtocol = 43,
6191 SystemFirmwareIntermediary = 44,
6192 UnknownOrdinal_(u16) = 45,
6193 }
6194 impl ::std::convert::From<u16> for ExtendedCapabilityId {
6195 fn from(value: u16) -> Self {
6196 match value {
6197 0 => Self::Null,
6198 1 => Self::AdvancedErrorReporting,
6199 2 => Self::VirtualChannelNoMfvc,
6200 3 => Self::DeviceSerialNumber,
6201 4 => Self::PowerBudgeting,
6202 5 => Self::RootComplexLinkDeclaration,
6203 6 => Self::RootComplexInternalLinkControl,
6204 7 => Self::RootComplexEventCollectorEndpointAssociation,
6205 8 => Self::MultiFunctionVirtualChannel,
6206 9 => Self::VirtualChannel,
6207 10 => Self::Rcrb,
6208 11 => Self::Vendor,
6209 12 => Self::Cac,
6210 13 => Self::Acs,
6211 14 => Self::Ari,
6212 15 => Self::Ats,
6213 16 => Self::SrIov,
6214 17 => Self::MrIov,
6215 18 => Self::Multicast,
6216 19 => Self::Pri,
6217 20 => Self::EnhancedAllocation,
6218 21 => Self::ResizableBar,
6219 22 => Self::DynamicPowerAllocation,
6220 23 => Self::Tph,
6221 24 => Self::LatencyToleranceReporting,
6222 25 => Self::SecondaryPciExpress,
6223 26 => Self::Pmux,
6224 27 => Self::Pasid,
6225 28 => Self::Lnr,
6226 29 => Self::Dpc,
6227 30 => Self::L1PmSubstates,
6228 31 => Self::PrecisionTimeMeasurement,
6229 32 => Self::Mpcie,
6230 33 => Self::FrsQueueing,
6231 34 => Self::ReadinessTimeReporting,
6232 35 => Self::DesignatedVendor,
6233 36 => Self::VfResizableBar,
6234 37 => Self::DataLinkFeature,
6235 38 => Self::PhysicalLayer16,
6236 39 => Self::LaneMarginingAtReceiver,
6237 40 => Self::HierarchyId,
6238 41 => Self::NativePcieEnclosure,
6239 42 => Self::PhysicalLayer32,
6240 43 => Self::AlternateProtocol,
6241 44 => Self::SystemFirmwareIntermediary,
6242
6243 _ => Self::UnknownOrdinal_(value),
6244 }
6245 }
6246 }
6247
6248 impl ::std::convert::From<ExtendedCapabilityId> for u16 {
6249 fn from(value: ExtendedCapabilityId) -> Self {
6250 match value {
6251 ExtendedCapabilityId::Null => 0,
6252 ExtendedCapabilityId::AdvancedErrorReporting => 1,
6253 ExtendedCapabilityId::VirtualChannelNoMfvc => 2,
6254 ExtendedCapabilityId::DeviceSerialNumber => 3,
6255 ExtendedCapabilityId::PowerBudgeting => 4,
6256 ExtendedCapabilityId::RootComplexLinkDeclaration => 5,
6257 ExtendedCapabilityId::RootComplexInternalLinkControl => 6,
6258 ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => 7,
6259 ExtendedCapabilityId::MultiFunctionVirtualChannel => 8,
6260 ExtendedCapabilityId::VirtualChannel => 9,
6261 ExtendedCapabilityId::Rcrb => 10,
6262 ExtendedCapabilityId::Vendor => 11,
6263 ExtendedCapabilityId::Cac => 12,
6264 ExtendedCapabilityId::Acs => 13,
6265 ExtendedCapabilityId::Ari => 14,
6266 ExtendedCapabilityId::Ats => 15,
6267 ExtendedCapabilityId::SrIov => 16,
6268 ExtendedCapabilityId::MrIov => 17,
6269 ExtendedCapabilityId::Multicast => 18,
6270 ExtendedCapabilityId::Pri => 19,
6271 ExtendedCapabilityId::EnhancedAllocation => 20,
6272 ExtendedCapabilityId::ResizableBar => 21,
6273 ExtendedCapabilityId::DynamicPowerAllocation => 22,
6274 ExtendedCapabilityId::Tph => 23,
6275 ExtendedCapabilityId::LatencyToleranceReporting => 24,
6276 ExtendedCapabilityId::SecondaryPciExpress => 25,
6277 ExtendedCapabilityId::Pmux => 26,
6278 ExtendedCapabilityId::Pasid => 27,
6279 ExtendedCapabilityId::Lnr => 28,
6280 ExtendedCapabilityId::Dpc => 29,
6281 ExtendedCapabilityId::L1PmSubstates => 30,
6282 ExtendedCapabilityId::PrecisionTimeMeasurement => 31,
6283 ExtendedCapabilityId::Mpcie => 32,
6284 ExtendedCapabilityId::FrsQueueing => 33,
6285 ExtendedCapabilityId::ReadinessTimeReporting => 34,
6286 ExtendedCapabilityId::DesignatedVendor => 35,
6287 ExtendedCapabilityId::VfResizableBar => 36,
6288 ExtendedCapabilityId::DataLinkFeature => 37,
6289 ExtendedCapabilityId::PhysicalLayer16 => 38,
6290 ExtendedCapabilityId::LaneMarginingAtReceiver => 39,
6291 ExtendedCapabilityId::HierarchyId => 40,
6292 ExtendedCapabilityId::NativePcieEnclosure => 41,
6293 ExtendedCapabilityId::PhysicalLayer32 => 42,
6294 ExtendedCapabilityId::AlternateProtocol => 43,
6295 ExtendedCapabilityId::SystemFirmwareIntermediary => 44,
6296
6297 ExtendedCapabilityId::UnknownOrdinal_(value) => value,
6298 }
6299 }
6300 }
6301
6302 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
6303 for ExtendedCapabilityId
6304 where
6305 ___E: ?Sized,
6306 {
6307 #[inline]
6308 fn encode(
6309 self,
6310 encoder: &mut ___E,
6311 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
6312 _: (),
6313 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6314 ::fidl_next::Encode::encode(&self, encoder, out, ())
6315 }
6316 }
6317
6318 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>
6319 for &'a ExtendedCapabilityId
6320 where
6321 ___E: ?Sized,
6322 {
6323 #[inline]
6324 fn encode(
6325 self,
6326 encoder: &mut ___E,
6327 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapabilityId>,
6328 _: (),
6329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6330 ::fidl_next::munge!(let crate::wire::ExtendedCapabilityId { value } = out);
6331 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
6332 ExtendedCapabilityId::Null => 0,
6333
6334 ExtendedCapabilityId::AdvancedErrorReporting => 1,
6335
6336 ExtendedCapabilityId::VirtualChannelNoMfvc => 2,
6337
6338 ExtendedCapabilityId::DeviceSerialNumber => 3,
6339
6340 ExtendedCapabilityId::PowerBudgeting => 4,
6341
6342 ExtendedCapabilityId::RootComplexLinkDeclaration => 5,
6343
6344 ExtendedCapabilityId::RootComplexInternalLinkControl => 6,
6345
6346 ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => 7,
6347
6348 ExtendedCapabilityId::MultiFunctionVirtualChannel => 8,
6349
6350 ExtendedCapabilityId::VirtualChannel => 9,
6351
6352 ExtendedCapabilityId::Rcrb => 10,
6353
6354 ExtendedCapabilityId::Vendor => 11,
6355
6356 ExtendedCapabilityId::Cac => 12,
6357
6358 ExtendedCapabilityId::Acs => 13,
6359
6360 ExtendedCapabilityId::Ari => 14,
6361
6362 ExtendedCapabilityId::Ats => 15,
6363
6364 ExtendedCapabilityId::SrIov => 16,
6365
6366 ExtendedCapabilityId::MrIov => 17,
6367
6368 ExtendedCapabilityId::Multicast => 18,
6369
6370 ExtendedCapabilityId::Pri => 19,
6371
6372 ExtendedCapabilityId::EnhancedAllocation => 20,
6373
6374 ExtendedCapabilityId::ResizableBar => 21,
6375
6376 ExtendedCapabilityId::DynamicPowerAllocation => 22,
6377
6378 ExtendedCapabilityId::Tph => 23,
6379
6380 ExtendedCapabilityId::LatencyToleranceReporting => 24,
6381
6382 ExtendedCapabilityId::SecondaryPciExpress => 25,
6383
6384 ExtendedCapabilityId::Pmux => 26,
6385
6386 ExtendedCapabilityId::Pasid => 27,
6387
6388 ExtendedCapabilityId::Lnr => 28,
6389
6390 ExtendedCapabilityId::Dpc => 29,
6391
6392 ExtendedCapabilityId::L1PmSubstates => 30,
6393
6394 ExtendedCapabilityId::PrecisionTimeMeasurement => 31,
6395
6396 ExtendedCapabilityId::Mpcie => 32,
6397
6398 ExtendedCapabilityId::FrsQueueing => 33,
6399
6400 ExtendedCapabilityId::ReadinessTimeReporting => 34,
6401
6402 ExtendedCapabilityId::DesignatedVendor => 35,
6403
6404 ExtendedCapabilityId::VfResizableBar => 36,
6405
6406 ExtendedCapabilityId::DataLinkFeature => 37,
6407
6408 ExtendedCapabilityId::PhysicalLayer16 => 38,
6409
6410 ExtendedCapabilityId::LaneMarginingAtReceiver => 39,
6411
6412 ExtendedCapabilityId::HierarchyId => 40,
6413
6414 ExtendedCapabilityId::NativePcieEnclosure => 41,
6415
6416 ExtendedCapabilityId::PhysicalLayer32 => 42,
6417
6418 ExtendedCapabilityId::AlternateProtocol => 43,
6419
6420 ExtendedCapabilityId::SystemFirmwareIntermediary => 44,
6421
6422 ExtendedCapabilityId::UnknownOrdinal_(value) => value,
6423 }));
6424
6425 Ok(())
6426 }
6427 }
6428
6429 impl ::core::convert::From<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
6430 fn from(wire: crate::wire::ExtendedCapabilityId) -> Self {
6431 match u16::from(wire.value) {
6432 0 => Self::Null,
6433
6434 1 => Self::AdvancedErrorReporting,
6435
6436 2 => Self::VirtualChannelNoMfvc,
6437
6438 3 => Self::DeviceSerialNumber,
6439
6440 4 => Self::PowerBudgeting,
6441
6442 5 => Self::RootComplexLinkDeclaration,
6443
6444 6 => Self::RootComplexInternalLinkControl,
6445
6446 7 => Self::RootComplexEventCollectorEndpointAssociation,
6447
6448 8 => Self::MultiFunctionVirtualChannel,
6449
6450 9 => Self::VirtualChannel,
6451
6452 10 => Self::Rcrb,
6453
6454 11 => Self::Vendor,
6455
6456 12 => Self::Cac,
6457
6458 13 => Self::Acs,
6459
6460 14 => Self::Ari,
6461
6462 15 => Self::Ats,
6463
6464 16 => Self::SrIov,
6465
6466 17 => Self::MrIov,
6467
6468 18 => Self::Multicast,
6469
6470 19 => Self::Pri,
6471
6472 20 => Self::EnhancedAllocation,
6473
6474 21 => Self::ResizableBar,
6475
6476 22 => Self::DynamicPowerAllocation,
6477
6478 23 => Self::Tph,
6479
6480 24 => Self::LatencyToleranceReporting,
6481
6482 25 => Self::SecondaryPciExpress,
6483
6484 26 => Self::Pmux,
6485
6486 27 => Self::Pasid,
6487
6488 28 => Self::Lnr,
6489
6490 29 => Self::Dpc,
6491
6492 30 => Self::L1PmSubstates,
6493
6494 31 => Self::PrecisionTimeMeasurement,
6495
6496 32 => Self::Mpcie,
6497
6498 33 => Self::FrsQueueing,
6499
6500 34 => Self::ReadinessTimeReporting,
6501
6502 35 => Self::DesignatedVendor,
6503
6504 36 => Self::VfResizableBar,
6505
6506 37 => Self::DataLinkFeature,
6507
6508 38 => Self::PhysicalLayer16,
6509
6510 39 => Self::LaneMarginingAtReceiver,
6511
6512 40 => Self::HierarchyId,
6513
6514 41 => Self::NativePcieEnclosure,
6515
6516 42 => Self::PhysicalLayer32,
6517
6518 43 => Self::AlternateProtocol,
6519
6520 44 => Self::SystemFirmwareIntermediary,
6521
6522 value => Self::UnknownOrdinal_(value),
6523 }
6524 }
6525 }
6526
6527 impl ::fidl_next::FromWire<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
6528 #[inline]
6529 fn from_wire(wire: crate::wire::ExtendedCapabilityId) -> Self {
6530 Self::from(wire)
6531 }
6532 }
6533
6534 impl ::fidl_next::FromWireRef<crate::wire::ExtendedCapabilityId> for ExtendedCapabilityId {
6535 #[inline]
6536 fn from_wire_ref(wire: &crate::wire::ExtendedCapabilityId) -> Self {
6537 Self::from(*wire)
6538 }
6539 }
6540
6541 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6542 #[repr(C)]
6543 pub struct DeviceGetExtendedCapabilitiesRequest {
6544 pub id: crate::natural::ExtendedCapabilityId,
6545 }
6546
6547 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
6548 for DeviceGetExtendedCapabilitiesRequest
6549 where
6550 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6551 {
6552 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6553 Self,
6554 crate::wire::DeviceGetExtendedCapabilitiesRequest,
6555 > = unsafe {
6556 ::fidl_next::CopyOptimization::enable_if(
6557 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::Encode<
6558 crate::wire::ExtendedCapabilityId,
6559 ___E,
6560 >>::COPY_OPTIMIZATION
6561 .is_enabled(),
6562 )
6563 };
6564
6565 #[inline]
6566 fn encode(
6567 self,
6568 encoder_: &mut ___E,
6569 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6570 _: (),
6571 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6572 ::fidl_next::munge! {
6573 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
6574 id,
6575
6576 } = out_;
6577 }
6578
6579 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
6580
6581 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
6582
6583 Ok(())
6584 }
6585 }
6586
6587 unsafe impl<'a, ___E>
6588 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
6589 for &'a DeviceGetExtendedCapabilitiesRequest
6590 where
6591 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6592 {
6593 #[inline]
6594 fn encode(
6595 self,
6596 encoder_: &mut ___E,
6597 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6598 _: (),
6599 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6600 ::fidl_next::munge! {
6601 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
6602 id,
6603
6604 } = out_;
6605 }
6606
6607 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
6608
6609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
6610
6611 Ok(())
6612 }
6613 }
6614
6615 unsafe impl<___E>
6616 ::fidl_next::EncodeOption<
6617 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6618 ___E,
6619 > for DeviceGetExtendedCapabilitiesRequest
6620 where
6621 ___E: ::fidl_next::Encoder + ?Sized,
6622 DeviceGetExtendedCapabilitiesRequest:
6623 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
6624 {
6625 #[inline]
6626 fn encode_option(
6627 this: ::core::option::Option<Self>,
6628 encoder: &mut ___E,
6629 out: &mut ::core::mem::MaybeUninit<
6630 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6631 >,
6632 _: (),
6633 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6634 if let Some(inner) = this {
6635 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6636 ::fidl_next::wire::Box::encode_present(out);
6637 } else {
6638 ::fidl_next::wire::Box::encode_absent(out);
6639 }
6640
6641 Ok(())
6642 }
6643 }
6644
6645 unsafe impl<'a, ___E>
6646 ::fidl_next::EncodeOption<
6647 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6648 ___E,
6649 > for &'a DeviceGetExtendedCapabilitiesRequest
6650 where
6651 ___E: ::fidl_next::Encoder + ?Sized,
6652 &'a DeviceGetExtendedCapabilitiesRequest:
6653 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>,
6654 {
6655 #[inline]
6656 fn encode_option(
6657 this: ::core::option::Option<Self>,
6658 encoder: &mut ___E,
6659 out: &mut ::core::mem::MaybeUninit<
6660 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetExtendedCapabilitiesRequest>,
6661 >,
6662 _: (),
6663 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6664 if let Some(inner) = this {
6665 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6666 ::fidl_next::wire::Box::encode_present(out);
6667 } else {
6668 ::fidl_next::wire::Box::encode_absent(out);
6669 }
6670
6671 Ok(())
6672 }
6673 }
6674
6675 impl ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6676 for DeviceGetExtendedCapabilitiesRequest
6677 {
6678 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6679 crate::wire::DeviceGetExtendedCapabilitiesRequest,
6680 Self,
6681 > = unsafe {
6682 ::fidl_next::CopyOptimization::enable_if(
6683 true && <crate::natural::ExtendedCapabilityId as ::fidl_next::FromWire<
6684 crate::wire::ExtendedCapabilityId,
6685 >>::COPY_OPTIMIZATION
6686 .is_enabled(),
6687 )
6688 };
6689
6690 #[inline]
6691 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6692 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
6693 }
6694 }
6695
6696 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesRequest>
6697 for DeviceGetExtendedCapabilitiesRequest
6698 {
6699 #[inline]
6700 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesRequest) -> Self {
6701 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
6702 }
6703 }
6704
6705 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6706 pub struct DeviceGetExtendedCapabilitiesResponse {
6707 pub offsets: ::std::vec::Vec<u16>,
6708 }
6709
6710 unsafe impl<___E>
6711 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6712 for DeviceGetExtendedCapabilitiesResponse
6713 where
6714 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6715 ___E: ::fidl_next::Encoder,
6716 {
6717 #[inline]
6718 fn encode(
6719 self,
6720 encoder_: &mut ___E,
6721 out_: &mut ::core::mem::MaybeUninit<
6722 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6723 >,
6724 _: (),
6725 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6726 ::fidl_next::munge! {
6727 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6728 offsets,
6729
6730 } = out_;
6731 }
6732
6733 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
6734
6735 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6736 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6737
6738 Ok(())
6739 }
6740 }
6741
6742 unsafe impl<'a, ___E>
6743 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
6744 for &'a DeviceGetExtendedCapabilitiesResponse
6745 where
6746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6747 ___E: ::fidl_next::Encoder,
6748 {
6749 #[inline]
6750 fn encode(
6751 self,
6752 encoder_: &mut ___E,
6753 out_: &mut ::core::mem::MaybeUninit<
6754 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6755 >,
6756 _: (),
6757 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6758 ::fidl_next::munge! {
6759 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
6760 offsets,
6761
6762 } = out_;
6763 }
6764
6765 ::fidl_next::Encode::encode(&self.offsets, encoder_, offsets, (32, ()))?;
6766
6767 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offsets.as_mut_ptr()) };
6768 ::fidl_next::Constrained::validate(_field, (32, ()))?;
6769
6770 Ok(())
6771 }
6772 }
6773
6774 unsafe impl<___E>
6775 ::fidl_next::EncodeOption<
6776 ::fidl_next::wire::Box<
6777 'static,
6778 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6779 >,
6780 ___E,
6781 > for DeviceGetExtendedCapabilitiesResponse
6782 where
6783 ___E: ::fidl_next::Encoder + ?Sized,
6784 DeviceGetExtendedCapabilitiesResponse:
6785 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6786 {
6787 #[inline]
6788 fn encode_option(
6789 this: ::core::option::Option<Self>,
6790 encoder: &mut ___E,
6791 out: &mut ::core::mem::MaybeUninit<
6792 ::fidl_next::wire::Box<
6793 'static,
6794 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6795 >,
6796 >,
6797 _: (),
6798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6799 if let Some(inner) = this {
6800 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6801 ::fidl_next::wire::Box::encode_present(out);
6802 } else {
6803 ::fidl_next::wire::Box::encode_absent(out);
6804 }
6805
6806 Ok(())
6807 }
6808 }
6809
6810 unsafe impl<'a, ___E>
6811 ::fidl_next::EncodeOption<
6812 ::fidl_next::wire::Box<
6813 'static,
6814 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6815 >,
6816 ___E,
6817 > for &'a DeviceGetExtendedCapabilitiesResponse
6818 where
6819 ___E: ::fidl_next::Encoder + ?Sized,
6820 &'a DeviceGetExtendedCapabilitiesResponse:
6821 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>,
6822 {
6823 #[inline]
6824 fn encode_option(
6825 this: ::core::option::Option<Self>,
6826 encoder: &mut ___E,
6827 out: &mut ::core::mem::MaybeUninit<
6828 ::fidl_next::wire::Box<
6829 'static,
6830 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
6831 >,
6832 >,
6833 _: (),
6834 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6835 if let Some(inner) = this {
6836 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6837 ::fidl_next::wire::Box::encode_present(out);
6838 } else {
6839 ::fidl_next::wire::Box::encode_absent(out);
6840 }
6841
6842 Ok(())
6843 }
6844 }
6845
6846 impl<'de> ::fidl_next::FromWire<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6847 for DeviceGetExtendedCapabilitiesResponse
6848 {
6849 #[inline]
6850 fn from_wire(wire: crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6851 Self { offsets: ::fidl_next::FromWire::from_wire(wire.offsets) }
6852 }
6853 }
6854
6855 impl<'de> ::fidl_next::FromWireRef<crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>>
6856 for DeviceGetExtendedCapabilitiesResponse
6857 {
6858 #[inline]
6859 fn from_wire_ref(wire: &crate::wire::DeviceGetExtendedCapabilitiesResponse<'de>) -> Self {
6860 Self { offsets: ::fidl_next::FromWireRef::from_wire_ref(&wire.offsets) }
6861 }
6862 }
6863
6864 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6865 #[repr(C)]
6866 pub struct DeviceGetBtiRequest {
6867 pub index: u32,
6868 }
6869
6870 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6871 for DeviceGetBtiRequest
6872 where
6873 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6874 {
6875 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6876 Self,
6877 crate::wire::DeviceGetBtiRequest,
6878 > = unsafe {
6879 ::fidl_next::CopyOptimization::enable_if(
6880 true
6881
6882 && <
6883 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
6884 >::COPY_OPTIMIZATION.is_enabled()
6885
6886 )
6887 };
6888
6889 #[inline]
6890 fn encode(
6891 self,
6892 encoder_: &mut ___E,
6893 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6894 _: (),
6895 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6896 ::fidl_next::munge! {
6897 let crate::wire::DeviceGetBtiRequest {
6898 index,
6899
6900 } = out_;
6901 }
6902
6903 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
6904
6905 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6906
6907 Ok(())
6908 }
6909 }
6910
6911 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
6912 for &'a DeviceGetBtiRequest
6913 where
6914 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6915 {
6916 #[inline]
6917 fn encode(
6918 self,
6919 encoder_: &mut ___E,
6920 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
6921 _: (),
6922 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6923 ::fidl_next::munge! {
6924 let crate::wire::DeviceGetBtiRequest {
6925 index,
6926
6927 } = out_;
6928 }
6929
6930 ::fidl_next::Encode::encode(&self.index, encoder_, index, ())?;
6931
6932 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(index.as_mut_ptr()) };
6933
6934 Ok(())
6935 }
6936 }
6937
6938 unsafe impl<___E>
6939 ::fidl_next::EncodeOption<
6940 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6941 ___E,
6942 > for DeviceGetBtiRequest
6943 where
6944 ___E: ::fidl_next::Encoder + ?Sized,
6945 DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6946 {
6947 #[inline]
6948 fn encode_option(
6949 this: ::core::option::Option<Self>,
6950 encoder: &mut ___E,
6951 out: &mut ::core::mem::MaybeUninit<
6952 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6953 >,
6954 _: (),
6955 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6956 if let Some(inner) = this {
6957 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6958 ::fidl_next::wire::Box::encode_present(out);
6959 } else {
6960 ::fidl_next::wire::Box::encode_absent(out);
6961 }
6962
6963 Ok(())
6964 }
6965 }
6966
6967 unsafe impl<'a, ___E>
6968 ::fidl_next::EncodeOption<
6969 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6970 ___E,
6971 > for &'a DeviceGetBtiRequest
6972 where
6973 ___E: ::fidl_next::Encoder + ?Sized,
6974 &'a DeviceGetBtiRequest: ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>,
6975 {
6976 #[inline]
6977 fn encode_option(
6978 this: ::core::option::Option<Self>,
6979 encoder: &mut ___E,
6980 out: &mut ::core::mem::MaybeUninit<
6981 ::fidl_next::wire::Box<'static, crate::wire::DeviceGetBtiRequest>,
6982 >,
6983 _: (),
6984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6985 if let Some(inner) = this {
6986 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6987 ::fidl_next::wire::Box::encode_present(out);
6988 } else {
6989 ::fidl_next::wire::Box::encode_absent(out);
6990 }
6991
6992 Ok(())
6993 }
6994 }
6995
6996 impl ::fidl_next::FromWire<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
6997 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6998 crate::wire::DeviceGetBtiRequest,
6999 Self,
7000 > = unsafe {
7001 ::fidl_next::CopyOptimization::enable_if(
7002 true
7003 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
7004 .is_enabled(),
7005 )
7006 };
7007
7008 #[inline]
7009 fn from_wire(wire: crate::wire::DeviceGetBtiRequest) -> Self {
7010 Self { index: ::fidl_next::FromWire::from_wire(wire.index) }
7011 }
7012 }
7013
7014 impl ::fidl_next::FromWireRef<crate::wire::DeviceGetBtiRequest> for DeviceGetBtiRequest {
7015 #[inline]
7016 fn from_wire_ref(wire: &crate::wire::DeviceGetBtiRequest) -> Self {
7017 Self { index: ::fidl_next::FromWireRef::from_wire_ref(&wire.index) }
7018 }
7019 }
7020
7021 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7022 #[repr(u8)]
7023 pub enum HeaderType {
7024 Standard = 0,
7025 Bridge = 1,
7026 CardBus = 2,
7027 Mask = 127,
7028 MultiFn = 128,
7029 UnknownOrdinal_(u8) = 129,
7030 }
7031 impl ::std::convert::From<u8> for HeaderType {
7032 fn from(value: u8) -> Self {
7033 match value {
7034 0 => Self::Standard,
7035 1 => Self::Bridge,
7036 2 => Self::CardBus,
7037 127 => Self::Mask,
7038 128 => Self::MultiFn,
7039
7040 _ => Self::UnknownOrdinal_(value),
7041 }
7042 }
7043 }
7044
7045 impl ::std::convert::From<HeaderType> for u8 {
7046 fn from(value: HeaderType) -> Self {
7047 match value {
7048 HeaderType::Standard => 0,
7049 HeaderType::Bridge => 1,
7050 HeaderType::CardBus => 2,
7051 HeaderType::Mask => 127,
7052 HeaderType::MultiFn => 128,
7053
7054 HeaderType::UnknownOrdinal_(value) => value,
7055 }
7056 }
7057 }
7058
7059 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for HeaderType
7060 where
7061 ___E: ?Sized,
7062 {
7063 #[inline]
7064 fn encode(
7065 self,
7066 encoder: &mut ___E,
7067 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
7068 _: (),
7069 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7070 ::fidl_next::Encode::encode(&self, encoder, out, ())
7071 }
7072 }
7073
7074 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HeaderType, ___E> for &'a HeaderType
7075 where
7076 ___E: ?Sized,
7077 {
7078 #[inline]
7079 fn encode(
7080 self,
7081 encoder: &mut ___E,
7082 out: &mut ::core::mem::MaybeUninit<crate::wire::HeaderType>,
7083 _: (),
7084 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7085 ::fidl_next::munge!(let crate::wire::HeaderType { value } = out);
7086 let _ = value.write(u8::from(match *self {
7087 HeaderType::Standard => 0,
7088
7089 HeaderType::Bridge => 1,
7090
7091 HeaderType::CardBus => 2,
7092
7093 HeaderType::Mask => 127,
7094
7095 HeaderType::MultiFn => 128,
7096
7097 HeaderType::UnknownOrdinal_(value) => value,
7098 }));
7099
7100 Ok(())
7101 }
7102 }
7103
7104 impl ::core::convert::From<crate::wire::HeaderType> for HeaderType {
7105 fn from(wire: crate::wire::HeaderType) -> Self {
7106 match u8::from(wire.value) {
7107 0 => Self::Standard,
7108
7109 1 => Self::Bridge,
7110
7111 2 => Self::CardBus,
7112
7113 127 => Self::Mask,
7114
7115 128 => Self::MultiFn,
7116
7117 value => Self::UnknownOrdinal_(value),
7118 }
7119 }
7120 }
7121
7122 impl ::fidl_next::FromWire<crate::wire::HeaderType> for HeaderType {
7123 #[inline]
7124 fn from_wire(wire: crate::wire::HeaderType) -> Self {
7125 Self::from(wire)
7126 }
7127 }
7128
7129 impl ::fidl_next::FromWireRef<crate::wire::HeaderType> for HeaderType {
7130 #[inline]
7131 fn from_wire_ref(wire: &crate::wire::HeaderType) -> Self {
7132 Self::from(*wire)
7133 }
7134 }
7135
7136 ::fidl_next::bitflags::bitflags! {
7137 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Status: u16 {
7138 const INTERRUPT = 8;
7139 const NEW_CAPS = 16;
7140 const SIXTYSIX_MHZ = 32;
7141 const FAST_B2_B = 128;
7142 const MSTR_PERR = 256;
7143 const DEVSEL_LOW = 512;
7144 const DEVSEL_HIGH = 1024;
7145 const TARG_ABORT_SIG = 2048;
7146 const TARG_ABORT_RCV = 4096;
7147 const MSTR_ABORT_RCV = 8192;
7148 const SERR_SIG = 16384;
7149 const PERR = 32768;
7150 const _ = !0;
7151 }
7152 }
7153
7154 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Status, ___E> for Status
7155 where
7156 ___E: ?Sized,
7157 {
7158 #[inline]
7159 fn encode(
7160 self,
7161 encoder: &mut ___E,
7162 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
7163 _: (),
7164 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7165 ::fidl_next::Encode::encode(&self, encoder, out, ())
7166 }
7167 }
7168
7169 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Status, ___E> for &'a Status
7170 where
7171 ___E: ?Sized,
7172 {
7173 #[inline]
7174 fn encode(
7175 self,
7176 _: &mut ___E,
7177 out: &mut ::core::mem::MaybeUninit<crate::wire::Status>,
7178 _: (),
7179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7180 ::fidl_next::munge!(let crate::wire::Status { value } = out);
7181
7182 let _ = value.write(::fidl_next::wire::Uint16::from(self.bits()));
7183 Ok(())
7184 }
7185 }
7186
7187 impl ::core::convert::From<crate::wire::Status> for Status {
7188 fn from(wire: crate::wire::Status) -> Self {
7189 Self::from_bits_retain(u16::from(wire.value))
7190 }
7191 }
7192
7193 impl ::fidl_next::FromWire<crate::wire::Status> for Status {
7194 #[inline]
7195 fn from_wire(wire: crate::wire::Status) -> Self {
7196 Self::from(wire)
7197 }
7198 }
7199
7200 impl ::fidl_next::FromWireRef<crate::wire::Status> for Status {
7201 #[inline]
7202 fn from_wire_ref(wire: &crate::wire::Status) -> Self {
7203 Self::from(*wire)
7204 }
7205 }
7206}
7207
7208pub mod wire {
7209
7210 #[derive(Clone, Debug)]
7212 #[repr(C)]
7213 pub struct Address {
7214 pub bus: u8,
7215
7216 pub device: u8,
7217
7218 pub function: u8,
7219 }
7220
7221 static_assertions::const_assert_eq!(std::mem::size_of::<Address>(), 3);
7222 static_assertions::const_assert_eq!(std::mem::align_of::<Address>(), 1);
7223
7224 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, bus), 0);
7225
7226 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, device), 1);
7227
7228 static_assertions::const_assert_eq!(std::mem::offset_of!(Address, function), 2);
7229
7230 impl ::fidl_next::Constrained for Address {
7231 type Constraint = ();
7232
7233 fn validate(
7234 _: ::fidl_next::Slot<'_, Self>,
7235 _: Self::Constraint,
7236 ) -> Result<(), ::fidl_next::ValidationError> {
7237 Ok(())
7238 }
7239 }
7240
7241 unsafe impl ::fidl_next::Wire for Address {
7242 type Narrowed<'de> = Address;
7243
7244 #[inline]
7245 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7246 ::fidl_next::munge! {
7247 let Self {
7248 bus,
7249 device,
7250 function,
7251
7252 } = &mut *out_;
7253 }
7254
7255 ::fidl_next::Wire::zero_padding(bus);
7256
7257 ::fidl_next::Wire::zero_padding(device);
7258
7259 ::fidl_next::Wire::zero_padding(function);
7260 }
7261 }
7262
7263 unsafe impl<___D> ::fidl_next::Decode<___D> for Address
7264 where
7265 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7266 {
7267 fn decode(
7268 slot_: ::fidl_next::Slot<'_, Self>,
7269 decoder_: &mut ___D,
7270 _: (),
7271 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7272 ::fidl_next::munge! {
7273 let Self {
7274 mut bus,
7275 mut device,
7276 mut function,
7277
7278 } = slot_;
7279 }
7280
7281 let _field = bus.as_mut();
7282
7283 ::fidl_next::Decode::decode(bus.as_mut(), decoder_, ())?;
7284
7285 let _field = device.as_mut();
7286
7287 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
7288
7289 let _field = function.as_mut();
7290
7291 ::fidl_next::Decode::decode(function.as_mut(), decoder_, ())?;
7292
7293 Ok(())
7294 }
7295 }
7296
7297 impl ::fidl_next::IntoNatural for Address {
7298 type Natural = crate::natural::Address;
7299 }
7300
7301 #[derive(Clone, Debug)]
7303 #[repr(C)]
7304 pub struct BaseAddress {
7305 pub address: ::fidl_next::wire::Uint64,
7306
7307 pub size: ::fidl_next::wire::Uint64,
7308
7309 pub is_memory: bool,
7310
7311 pub is_prefetchable: bool,
7312
7313 pub is_64bit: bool,
7314
7315 pub id: u8,
7316 }
7317
7318 static_assertions::const_assert_eq!(std::mem::size_of::<BaseAddress>(), 24);
7319 static_assertions::const_assert_eq!(std::mem::align_of::<BaseAddress>(), 8);
7320
7321 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, address), 0);
7322
7323 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, size), 8);
7324
7325 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_memory), 16);
7326
7327 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_prefetchable), 17);
7328
7329 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, is_64bit), 18);
7330
7331 static_assertions::const_assert_eq!(std::mem::offset_of!(BaseAddress, id), 19);
7332
7333 impl ::fidl_next::Constrained for BaseAddress {
7334 type Constraint = ();
7335
7336 fn validate(
7337 _: ::fidl_next::Slot<'_, Self>,
7338 _: Self::Constraint,
7339 ) -> Result<(), ::fidl_next::ValidationError> {
7340 Ok(())
7341 }
7342 }
7343
7344 unsafe impl ::fidl_next::Wire for BaseAddress {
7345 type Narrowed<'de> = BaseAddress;
7346
7347 #[inline]
7348 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7349 ::fidl_next::munge! {
7350 let Self {
7351 address,
7352 size,
7353 is_memory,
7354 is_prefetchable,
7355 is_64bit,
7356 id,
7357
7358 } = &mut *out_;
7359 }
7360
7361 ::fidl_next::Wire::zero_padding(address);
7362
7363 ::fidl_next::Wire::zero_padding(size);
7364
7365 ::fidl_next::Wire::zero_padding(is_memory);
7366
7367 ::fidl_next::Wire::zero_padding(is_prefetchable);
7368
7369 ::fidl_next::Wire::zero_padding(is_64bit);
7370
7371 ::fidl_next::Wire::zero_padding(id);
7372
7373 unsafe {
7374 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
7375 }
7376 }
7377 }
7378
7379 unsafe impl<___D> ::fidl_next::Decode<___D> for BaseAddress
7380 where
7381 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7382 {
7383 fn decode(
7384 slot_: ::fidl_next::Slot<'_, Self>,
7385 decoder_: &mut ___D,
7386 _: (),
7387 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7388 if slot_.as_bytes()[20..24] != [0u8; 4] {
7389 return Err(::fidl_next::DecodeError::InvalidPadding);
7390 }
7391
7392 ::fidl_next::munge! {
7393 let Self {
7394 mut address,
7395 mut size,
7396 mut is_memory,
7397 mut is_prefetchable,
7398 mut is_64bit,
7399 mut id,
7400
7401 } = slot_;
7402 }
7403
7404 let _field = address.as_mut();
7405
7406 ::fidl_next::Decode::decode(address.as_mut(), decoder_, ())?;
7407
7408 let _field = size.as_mut();
7409
7410 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
7411
7412 let _field = is_memory.as_mut();
7413
7414 ::fidl_next::Decode::decode(is_memory.as_mut(), decoder_, ())?;
7415
7416 let _field = is_prefetchable.as_mut();
7417
7418 ::fidl_next::Decode::decode(is_prefetchable.as_mut(), decoder_, ())?;
7419
7420 let _field = is_64bit.as_mut();
7421
7422 ::fidl_next::Decode::decode(is_64bit.as_mut(), decoder_, ())?;
7423
7424 let _field = id.as_mut();
7425
7426 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7427
7428 Ok(())
7429 }
7430 }
7431
7432 impl ::fidl_next::IntoNatural for BaseAddress {
7433 type Natural = crate::natural::BaseAddress;
7434 }
7435
7436 #[derive(Clone, Debug)]
7438 #[repr(C)]
7439 pub struct Bdf {
7440 pub bus_id: u8,
7441
7442 pub device_id: u8,
7443
7444 pub function_id: u8,
7445 }
7446
7447 static_assertions::const_assert_eq!(std::mem::size_of::<Bdf>(), 3);
7448 static_assertions::const_assert_eq!(std::mem::align_of::<Bdf>(), 1);
7449
7450 static_assertions::const_assert_eq!(std::mem::offset_of!(Bdf, bus_id), 0);
7451
7452 static_assertions::const_assert_eq!(std::mem::offset_of!(Bdf, device_id), 1);
7453
7454 static_assertions::const_assert_eq!(std::mem::offset_of!(Bdf, function_id), 2);
7455
7456 impl ::fidl_next::Constrained for Bdf {
7457 type Constraint = ();
7458
7459 fn validate(
7460 _: ::fidl_next::Slot<'_, Self>,
7461 _: Self::Constraint,
7462 ) -> Result<(), ::fidl_next::ValidationError> {
7463 Ok(())
7464 }
7465 }
7466
7467 unsafe impl ::fidl_next::Wire for Bdf {
7468 type Narrowed<'de> = Bdf;
7469
7470 #[inline]
7471 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7472 ::fidl_next::munge! {
7473 let Self {
7474 bus_id,
7475 device_id,
7476 function_id,
7477
7478 } = &mut *out_;
7479 }
7480
7481 ::fidl_next::Wire::zero_padding(bus_id);
7482
7483 ::fidl_next::Wire::zero_padding(device_id);
7484
7485 ::fidl_next::Wire::zero_padding(function_id);
7486 }
7487 }
7488
7489 unsafe impl<___D> ::fidl_next::Decode<___D> for Bdf
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 bus_id,
7501 mut device_id,
7502 mut function_id,
7503
7504 } = slot_;
7505 }
7506
7507 let _field = bus_id.as_mut();
7508
7509 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
7510
7511 let _field = device_id.as_mut();
7512
7513 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
7514
7515 let _field = function_id.as_mut();
7516
7517 ::fidl_next::Decode::decode(function_id.as_mut(), decoder_, ())?;
7518
7519 Ok(())
7520 }
7521 }
7522
7523 impl ::fidl_next::IntoNatural for Bdf {
7524 type Natural = crate::natural::Bdf;
7525 }
7526
7527 pub type UseIntxWorkaroundType = ::fidl_next::wire::Unit;
7529
7530 #[repr(C)]
7532 pub struct BoardConfiguration<'de> {
7533 pub(crate) table: ::fidl_next::wire::Table<'de>,
7534 }
7535
7536 impl<'de> Drop for BoardConfiguration<'de> {
7537 fn drop(&mut self) {
7538 let _ = self.table.get(1).map(|envelope| unsafe {
7539 envelope.read_unchecked::<crate::wire::UseIntxWorkaroundType>()
7540 });
7541
7542 let _ = self.table.get(2).map(|envelope| unsafe {
7543 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Address>>()
7544 });
7545 }
7546 }
7547
7548 impl ::fidl_next::Constrained for BoardConfiguration<'_> {
7549 type Constraint = ();
7550
7551 fn validate(
7552 _: ::fidl_next::Slot<'_, Self>,
7553 _: Self::Constraint,
7554 ) -> Result<(), ::fidl_next::ValidationError> {
7555 Ok(())
7556 }
7557 }
7558
7559 unsafe impl ::fidl_next::Wire for BoardConfiguration<'static> {
7560 type Narrowed<'de> = BoardConfiguration<'de>;
7561
7562 #[inline]
7563 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7564 ::fidl_next::munge!(let Self { table } = out);
7565 ::fidl_next::wire::Table::zero_padding(table);
7566 }
7567 }
7568
7569 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BoardConfiguration<'de>
7570 where
7571 ___D: ::fidl_next::Decoder<'de> + ?Sized,
7572 {
7573 fn decode(
7574 slot: ::fidl_next::Slot<'_, Self>,
7575 decoder: &mut ___D,
7576 _: (),
7577 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7578 ::fidl_next::munge!(let Self { table } = slot);
7579
7580 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
7581 match ordinal {
7582 0 => unsafe { ::core::hint::unreachable_unchecked() },
7583
7584 1 => {
7585 ::fidl_next::wire::Envelope::decode_as::<
7586 ___D,
7587 crate::wire::UseIntxWorkaroundType,
7588 >(slot.as_mut(), decoder, ())?;
7589
7590 Ok(())
7591 }
7592
7593 2 => {
7594 ::fidl_next::wire::Envelope::decode_as::<
7595 ___D,
7596 ::fidl_next::wire::Vector<'de, crate::wire::Address>,
7597 >(slot.as_mut(), decoder, (4294967295, ()))?;
7598
7599 Ok(())
7600 }
7601
7602 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
7603 }
7604 })
7605 }
7606 }
7607
7608 impl<'de> BoardConfiguration<'de> {
7609 pub fn use_intx_workaround(
7610 &self,
7611 ) -> ::core::option::Option<&crate::wire::UseIntxWorkaroundType> {
7612 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
7613 }
7614
7615 pub fn take_use_intx_workaround(
7616 &mut self,
7617 ) -> ::core::option::Option<crate::wire::UseIntxWorkaroundType> {
7618 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
7619 }
7620
7621 pub fn devicetree_bdfs(
7622 &self,
7623 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Address>> {
7624 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
7625 }
7626
7627 pub fn take_devicetree_bdfs(
7628 &mut self,
7629 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::Address>> {
7630 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
7631 }
7632 }
7633
7634 impl<'de> ::core::fmt::Debug for BoardConfiguration<'de> {
7635 fn fmt(
7636 &self,
7637 f: &mut ::core::fmt::Formatter<'_>,
7638 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7639 f.debug_struct("BoardConfiguration")
7640 .field("use_intx_workaround", &self.use_intx_workaround())
7641 .field("devicetree_bdfs", &self.devicetree_bdfs())
7642 .finish()
7643 }
7644 }
7645
7646 impl<'de> ::fidl_next::IntoNatural for BoardConfiguration<'de> {
7647 type Natural = crate::natural::BoardConfiguration;
7648 }
7649
7650 #[derive(Clone, Debug)]
7652 #[repr(C)]
7653 pub struct Capability {
7654 pub id: u8,
7655
7656 pub offset: u8,
7657 }
7658
7659 static_assertions::const_assert_eq!(std::mem::size_of::<Capability>(), 2);
7660 static_assertions::const_assert_eq!(std::mem::align_of::<Capability>(), 1);
7661
7662 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, id), 0);
7663
7664 static_assertions::const_assert_eq!(std::mem::offset_of!(Capability, offset), 1);
7665
7666 impl ::fidl_next::Constrained for Capability {
7667 type Constraint = ();
7668
7669 fn validate(
7670 _: ::fidl_next::Slot<'_, Self>,
7671 _: Self::Constraint,
7672 ) -> Result<(), ::fidl_next::ValidationError> {
7673 Ok(())
7674 }
7675 }
7676
7677 unsafe impl ::fidl_next::Wire for Capability {
7678 type Narrowed<'de> = Capability;
7679
7680 #[inline]
7681 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7682 ::fidl_next::munge! {
7683 let Self {
7684 id,
7685 offset,
7686
7687 } = &mut *out_;
7688 }
7689
7690 ::fidl_next::Wire::zero_padding(id);
7691
7692 ::fidl_next::Wire::zero_padding(offset);
7693 }
7694 }
7695
7696 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability
7697 where
7698 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7699 {
7700 fn decode(
7701 slot_: ::fidl_next::Slot<'_, Self>,
7702 decoder_: &mut ___D,
7703 _: (),
7704 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7705 ::fidl_next::munge! {
7706 let Self {
7707 mut id,
7708 mut offset,
7709
7710 } = slot_;
7711 }
7712
7713 let _field = id.as_mut();
7714
7715 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7716
7717 let _field = offset.as_mut();
7718
7719 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
7720
7721 Ok(())
7722 }
7723 }
7724
7725 impl ::fidl_next::IntoNatural for Capability {
7726 type Natural = crate::natural::Capability;
7727 }
7728
7729 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7731 #[repr(transparent)]
7732 pub struct CapabilityId {
7733 pub(crate) value: u8,
7734 }
7735
7736 impl ::fidl_next::Constrained for CapabilityId {
7737 type Constraint = ();
7738
7739 fn validate(
7740 _: ::fidl_next::Slot<'_, Self>,
7741 _: Self::Constraint,
7742 ) -> Result<(), ::fidl_next::ValidationError> {
7743 Ok(())
7744 }
7745 }
7746
7747 unsafe impl ::fidl_next::Wire for CapabilityId {
7748 type Narrowed<'de> = Self;
7749
7750 #[inline]
7751 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
7752 }
7754 }
7755
7756 impl CapabilityId {
7757 pub const NULL: CapabilityId = CapabilityId { value: 0 };
7758
7759 pub const PCI_PWR_MGMT: CapabilityId = CapabilityId { value: 1 };
7760
7761 pub const AGP: CapabilityId = CapabilityId { value: 2 };
7762
7763 pub const VITAL_PRODUCT_DATA: CapabilityId = CapabilityId { value: 3 };
7764
7765 pub const SLOT_IDENTIFICATION: CapabilityId = CapabilityId { value: 4 };
7766
7767 pub const MSI: CapabilityId = CapabilityId { value: 5 };
7768
7769 pub const COMPACT_PCI_HOTSWAP: CapabilityId = CapabilityId { value: 6 };
7770
7771 pub const PCIX: CapabilityId = CapabilityId { value: 7 };
7772
7773 pub const HYPERTRANSPORT: CapabilityId = CapabilityId { value: 8 };
7774
7775 pub const VENDOR: CapabilityId = CapabilityId { value: 9 };
7776
7777 pub const DEBUG_PORT: CapabilityId = CapabilityId { value: 10 };
7778
7779 pub const COMPACT_PCI_CRC: CapabilityId = CapabilityId { value: 11 };
7780
7781 pub const PCI_HOT_PLUG: CapabilityId = CapabilityId { value: 12 };
7782
7783 pub const PCI_BRIDGE_SUBSYSTEM_VID: CapabilityId = CapabilityId { value: 13 };
7784
7785 pub const AGP8_X: CapabilityId = CapabilityId { value: 14 };
7786
7787 pub const SECURE_DEVICE: CapabilityId = CapabilityId { value: 15 };
7788
7789 pub const PCI_EXPRESS: CapabilityId = CapabilityId { value: 16 };
7790
7791 pub const MSIX: CapabilityId = CapabilityId { value: 17 };
7792
7793 pub const SATA_DATA_NDX_CFG: CapabilityId = CapabilityId { value: 18 };
7794
7795 pub const ADVANCED_FEATURES: CapabilityId = CapabilityId { value: 19 };
7796
7797 pub const ENHANCED_ALLOCATION: CapabilityId = CapabilityId { value: 20 };
7798
7799 pub const FLATTENING_PORTAL_BRIDGE: CapabilityId = CapabilityId { value: 21 };
7800 }
7801
7802 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityId
7803 where
7804 ___D: ?Sized,
7805 {
7806 fn decode(
7807 slot: ::fidl_next::Slot<'_, Self>,
7808 _: &mut ___D,
7809 _: (),
7810 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7811 Ok(())
7812 }
7813 }
7814
7815 impl ::core::convert::From<crate::natural::CapabilityId> for CapabilityId {
7816 fn from(natural: crate::natural::CapabilityId) -> Self {
7817 match natural {
7818 crate::natural::CapabilityId::Null => CapabilityId::NULL,
7819
7820 crate::natural::CapabilityId::PciPwrMgmt => CapabilityId::PCI_PWR_MGMT,
7821
7822 crate::natural::CapabilityId::Agp => CapabilityId::AGP,
7823
7824 crate::natural::CapabilityId::VitalProductData => CapabilityId::VITAL_PRODUCT_DATA,
7825
7826 crate::natural::CapabilityId::SlotIdentification => {
7827 CapabilityId::SLOT_IDENTIFICATION
7828 }
7829
7830 crate::natural::CapabilityId::Msi => CapabilityId::MSI,
7831
7832 crate::natural::CapabilityId::CompactPciHotswap => {
7833 CapabilityId::COMPACT_PCI_HOTSWAP
7834 }
7835
7836 crate::natural::CapabilityId::Pcix => CapabilityId::PCIX,
7837
7838 crate::natural::CapabilityId::Hypertransport => CapabilityId::HYPERTRANSPORT,
7839
7840 crate::natural::CapabilityId::Vendor => CapabilityId::VENDOR,
7841
7842 crate::natural::CapabilityId::DebugPort => CapabilityId::DEBUG_PORT,
7843
7844 crate::natural::CapabilityId::CompactPciCrc => CapabilityId::COMPACT_PCI_CRC,
7845
7846 crate::natural::CapabilityId::PciHotPlug => CapabilityId::PCI_HOT_PLUG,
7847
7848 crate::natural::CapabilityId::PciBridgeSubsystemVid => {
7849 CapabilityId::PCI_BRIDGE_SUBSYSTEM_VID
7850 }
7851
7852 crate::natural::CapabilityId::Agp8X => CapabilityId::AGP8_X,
7853
7854 crate::natural::CapabilityId::SecureDevice => CapabilityId::SECURE_DEVICE,
7855
7856 crate::natural::CapabilityId::PciExpress => CapabilityId::PCI_EXPRESS,
7857
7858 crate::natural::CapabilityId::Msix => CapabilityId::MSIX,
7859
7860 crate::natural::CapabilityId::SataDataNdxCfg => CapabilityId::SATA_DATA_NDX_CFG,
7861
7862 crate::natural::CapabilityId::AdvancedFeatures => CapabilityId::ADVANCED_FEATURES,
7863
7864 crate::natural::CapabilityId::EnhancedAllocation => {
7865 CapabilityId::ENHANCED_ALLOCATION
7866 }
7867
7868 crate::natural::CapabilityId::FlatteningPortalBridge => {
7869 CapabilityId::FLATTENING_PORTAL_BRIDGE
7870 }
7871
7872 crate::natural::CapabilityId::UnknownOrdinal_(value) => {
7873 CapabilityId { value: u8::from(value) }
7874 }
7875 }
7876 }
7877 }
7878
7879 impl ::fidl_next::IntoNatural for CapabilityId {
7880 type Natural = crate::natural::CapabilityId;
7881 }
7882
7883 #[derive(Clone, Copy, Debug)]
7885 #[repr(transparent)]
7886 pub struct Command {
7887 pub(crate) value: ::fidl_next::wire::Uint16,
7888 }
7889
7890 impl ::fidl_next::Constrained for Command {
7891 type Constraint = ();
7892
7893 fn validate(
7894 _: ::fidl_next::Slot<'_, Self>,
7895 _: Self::Constraint,
7896 ) -> Result<(), ::fidl_next::ValidationError> {
7897 Ok(())
7898 }
7899 }
7900
7901 unsafe impl ::fidl_next::Wire for Command {
7902 type Narrowed<'de> = Self;
7903
7904 #[inline]
7905 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
7906 }
7908 }
7909
7910 unsafe impl<___D> ::fidl_next::Decode<___D> for Command
7911 where
7912 ___D: ?Sized,
7913 {
7914 fn decode(
7915 slot: ::fidl_next::Slot<'_, Self>,
7916 _: &mut ___D,
7917 _: (),
7918 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7919 Ok(())
7920 }
7921 }
7922
7923 impl ::core::convert::From<crate::natural::Command> for Command {
7924 fn from(natural: crate::natural::Command) -> Self {
7925 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
7926 }
7927 }
7928
7929 impl ::fidl_next::IntoNatural for Command {
7930 type Natural = crate::natural::Command;
7931 }
7932
7933 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7935 #[repr(transparent)]
7936 pub struct Config {
7937 pub(crate) value: ::fidl_next::wire::Uint16,
7938 }
7939
7940 impl ::fidl_next::Constrained for Config {
7941 type Constraint = ();
7942
7943 fn validate(
7944 _: ::fidl_next::Slot<'_, Self>,
7945 _: Self::Constraint,
7946 ) -> Result<(), ::fidl_next::ValidationError> {
7947 Ok(())
7948 }
7949 }
7950
7951 unsafe impl ::fidl_next::Wire for Config {
7952 type Narrowed<'de> = Self;
7953
7954 #[inline]
7955 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
7956 }
7958 }
7959
7960 impl Config {
7961 pub const VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(0) };
7962
7963 pub const DEVICE_ID: Config = Config { value: ::fidl_next::wire::Uint16(2) };
7964
7965 pub const COMMAND: Config = Config { value: ::fidl_next::wire::Uint16(4) };
7966
7967 pub const STATUS: Config = Config { value: ::fidl_next::wire::Uint16(6) };
7968
7969 pub const REVISION_ID: Config = Config { value: ::fidl_next::wire::Uint16(8) };
7970
7971 pub const CLASS_CODE_INTR: Config = Config { value: ::fidl_next::wire::Uint16(9) };
7972
7973 pub const CLASS_CODE_SUB: Config = Config { value: ::fidl_next::wire::Uint16(10) };
7974
7975 pub const CLASS_CODE_BASE: Config = Config { value: ::fidl_next::wire::Uint16(11) };
7976
7977 pub const CACHE_LINE_SIZE: Config = Config { value: ::fidl_next::wire::Uint16(12) };
7978
7979 pub const LATENCY_TIMER: Config = Config { value: ::fidl_next::wire::Uint16(13) };
7980
7981 pub const HEADER_TYPE: Config = Config { value: ::fidl_next::wire::Uint16(14) };
7982
7983 pub const BIST: Config = Config { value: ::fidl_next::wire::Uint16(15) };
7984
7985 pub const BASE_ADDRESSES: Config = Config { value: ::fidl_next::wire::Uint16(16) };
7986
7987 pub const CARDBUS_CIS_PTR: Config = Config { value: ::fidl_next::wire::Uint16(40) };
7988
7989 pub const SUBSYSTEM_VENDOR_ID: Config = Config { value: ::fidl_next::wire::Uint16(44) };
7990
7991 pub const SUBSYSTEM_ID: Config = Config { value: ::fidl_next::wire::Uint16(46) };
7992
7993 pub const EXP_ROM_ADDRESS: Config = Config { value: ::fidl_next::wire::Uint16(48) };
7994
7995 pub const CAPABILITIES_PTR: Config = Config { value: ::fidl_next::wire::Uint16(52) };
7996
7997 pub const INTERRUPT_LINE: Config = Config { value: ::fidl_next::wire::Uint16(60) };
7998
7999 pub const INTERRUPT_PIN: Config = Config { value: ::fidl_next::wire::Uint16(61) };
8000
8001 pub const MIN_GRANT: Config = Config { value: ::fidl_next::wire::Uint16(62) };
8002
8003 pub const MAX_LATENCY: Config = Config { value: ::fidl_next::wire::Uint16(63) };
8004 }
8005
8006 unsafe impl<___D> ::fidl_next::Decode<___D> for Config
8007 where
8008 ___D: ?Sized,
8009 {
8010 fn decode(
8011 slot: ::fidl_next::Slot<'_, Self>,
8012 _: &mut ___D,
8013 _: (),
8014 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8015 Ok(())
8016 }
8017 }
8018
8019 impl ::core::convert::From<crate::natural::Config> for Config {
8020 fn from(natural: crate::natural::Config) -> Self {
8021 match natural {
8022 crate::natural::Config::VendorId => Config::VENDOR_ID,
8023
8024 crate::natural::Config::DeviceId => Config::DEVICE_ID,
8025
8026 crate::natural::Config::Command => Config::COMMAND,
8027
8028 crate::natural::Config::Status => Config::STATUS,
8029
8030 crate::natural::Config::RevisionId => Config::REVISION_ID,
8031
8032 crate::natural::Config::ClassCodeIntr => Config::CLASS_CODE_INTR,
8033
8034 crate::natural::Config::ClassCodeSub => Config::CLASS_CODE_SUB,
8035
8036 crate::natural::Config::ClassCodeBase => Config::CLASS_CODE_BASE,
8037
8038 crate::natural::Config::CacheLineSize => Config::CACHE_LINE_SIZE,
8039
8040 crate::natural::Config::LatencyTimer => Config::LATENCY_TIMER,
8041
8042 crate::natural::Config::HeaderType => Config::HEADER_TYPE,
8043
8044 crate::natural::Config::Bist => Config::BIST,
8045
8046 crate::natural::Config::BaseAddresses => Config::BASE_ADDRESSES,
8047
8048 crate::natural::Config::CardbusCisPtr => Config::CARDBUS_CIS_PTR,
8049
8050 crate::natural::Config::SubsystemVendorId => Config::SUBSYSTEM_VENDOR_ID,
8051
8052 crate::natural::Config::SubsystemId => Config::SUBSYSTEM_ID,
8053
8054 crate::natural::Config::ExpRomAddress => Config::EXP_ROM_ADDRESS,
8055
8056 crate::natural::Config::CapabilitiesPtr => Config::CAPABILITIES_PTR,
8057
8058 crate::natural::Config::InterruptLine => Config::INTERRUPT_LINE,
8059
8060 crate::natural::Config::InterruptPin => Config::INTERRUPT_PIN,
8061
8062 crate::natural::Config::MinGrant => Config::MIN_GRANT,
8063
8064 crate::natural::Config::MaxLatency => Config::MAX_LATENCY,
8065
8066 crate::natural::Config::UnknownOrdinal_(value) => {
8067 Config { value: ::fidl_next::wire::Uint16::from(value) }
8068 }
8069 }
8070 }
8071 }
8072
8073 impl ::fidl_next::IntoNatural for Config {
8074 type Natural = crate::natural::Config;
8075 }
8076
8077 pub type ConfigOffset = u8;
8079
8080 #[derive(Debug)]
8082 #[repr(C)]
8083 pub struct HostBridgeInfo<'de> {
8084 pub name: ::fidl_next::wire::String<'de>,
8085
8086 pub start_bus_number: u8,
8087
8088 pub end_bus_number: u8,
8089
8090 pub segment_group: ::fidl_next::wire::Uint16,
8091 }
8092
8093 static_assertions::const_assert_eq!(std::mem::size_of::<HostBridgeInfo<'_>>(), 24);
8094 static_assertions::const_assert_eq!(std::mem::align_of::<HostBridgeInfo<'_>>(), 8);
8095
8096 static_assertions::const_assert_eq!(std::mem::offset_of!(HostBridgeInfo<'_>, name), 0);
8097
8098 static_assertions::const_assert_eq!(
8099 std::mem::offset_of!(HostBridgeInfo<'_>, start_bus_number),
8100 16
8101 );
8102
8103 static_assertions::const_assert_eq!(
8104 std::mem::offset_of!(HostBridgeInfo<'_>, end_bus_number),
8105 17
8106 );
8107
8108 static_assertions::const_assert_eq!(
8109 std::mem::offset_of!(HostBridgeInfo<'_>, segment_group),
8110 18
8111 );
8112
8113 impl ::fidl_next::Constrained for HostBridgeInfo<'_> {
8114 type Constraint = ();
8115
8116 fn validate(
8117 _: ::fidl_next::Slot<'_, Self>,
8118 _: Self::Constraint,
8119 ) -> Result<(), ::fidl_next::ValidationError> {
8120 Ok(())
8121 }
8122 }
8123
8124 unsafe impl ::fidl_next::Wire for HostBridgeInfo<'static> {
8125 type Narrowed<'de> = HostBridgeInfo<'de>;
8126
8127 #[inline]
8128 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8129 ::fidl_next::munge! {
8130 let Self {
8131 name,
8132 start_bus_number,
8133 end_bus_number,
8134 segment_group,
8135
8136 } = &mut *out_;
8137 }
8138
8139 ::fidl_next::Wire::zero_padding(name);
8140
8141 ::fidl_next::Wire::zero_padding(start_bus_number);
8142
8143 ::fidl_next::Wire::zero_padding(end_bus_number);
8144
8145 ::fidl_next::Wire::zero_padding(segment_group);
8146
8147 unsafe {
8148 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
8149 }
8150 }
8151 }
8152
8153 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for HostBridgeInfo<'de>
8154 where
8155 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8156 ___D: ::fidl_next::Decoder<'de>,
8157 {
8158 fn decode(
8159 slot_: ::fidl_next::Slot<'_, Self>,
8160 decoder_: &mut ___D,
8161 _: (),
8162 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8163 if slot_.as_bytes()[20..24] != [0u8; 4] {
8164 return Err(::fidl_next::DecodeError::InvalidPadding);
8165 }
8166
8167 ::fidl_next::munge! {
8168 let Self {
8169 mut name,
8170 mut start_bus_number,
8171 mut end_bus_number,
8172 mut segment_group,
8173
8174 } = slot_;
8175 }
8176
8177 let _field = name.as_mut();
8178 ::fidl_next::Constrained::validate(_field, 32)?;
8179 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 32)?;
8180
8181 let name = unsafe { name.deref_unchecked() };
8182
8183 if name.len() > 32 {
8184 return Err(::fidl_next::DecodeError::VectorTooLong {
8185 size: name.len() as u64,
8186 limit: 32,
8187 });
8188 }
8189
8190 let _field = start_bus_number.as_mut();
8191
8192 ::fidl_next::Decode::decode(start_bus_number.as_mut(), decoder_, ())?;
8193
8194 let _field = end_bus_number.as_mut();
8195
8196 ::fidl_next::Decode::decode(end_bus_number.as_mut(), decoder_, ())?;
8197
8198 let _field = segment_group.as_mut();
8199
8200 ::fidl_next::Decode::decode(segment_group.as_mut(), decoder_, ())?;
8201
8202 Ok(())
8203 }
8204 }
8205
8206 impl<'de> ::fidl_next::IntoNatural for HostBridgeInfo<'de> {
8207 type Natural = crate::natural::HostBridgeInfo;
8208 }
8209
8210 #[derive(Debug)]
8212 #[repr(C)]
8213 pub struct DebugGetHostBridgeInfoResponse<'de> {
8214 pub info: crate::wire::HostBridgeInfo<'de>,
8215 }
8216
8217 static_assertions::const_assert_eq!(
8218 std::mem::size_of::<DebugGetHostBridgeInfoResponse<'_>>(),
8219 24
8220 );
8221 static_assertions::const_assert_eq!(
8222 std::mem::align_of::<DebugGetHostBridgeInfoResponse<'_>>(),
8223 8
8224 );
8225
8226 static_assertions::const_assert_eq!(
8227 std::mem::offset_of!(DebugGetHostBridgeInfoResponse<'_>, info),
8228 0
8229 );
8230
8231 impl ::fidl_next::Constrained for DebugGetHostBridgeInfoResponse<'_> {
8232 type Constraint = ();
8233
8234 fn validate(
8235 _: ::fidl_next::Slot<'_, Self>,
8236 _: Self::Constraint,
8237 ) -> Result<(), ::fidl_next::ValidationError> {
8238 Ok(())
8239 }
8240 }
8241
8242 unsafe impl ::fidl_next::Wire for DebugGetHostBridgeInfoResponse<'static> {
8243 type Narrowed<'de> = DebugGetHostBridgeInfoResponse<'de>;
8244
8245 #[inline]
8246 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8247 ::fidl_next::munge! {
8248 let Self {
8249 info,
8250
8251 } = &mut *out_;
8252 }
8253
8254 ::fidl_next::Wire::zero_padding(info);
8255 }
8256 }
8257
8258 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugGetHostBridgeInfoResponse<'de>
8259 where
8260 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8261 ___D: ::fidl_next::Decoder<'de>,
8262 {
8263 fn decode(
8264 slot_: ::fidl_next::Slot<'_, Self>,
8265 decoder_: &mut ___D,
8266 _: (),
8267 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8268 ::fidl_next::munge! {
8269 let Self {
8270 mut info,
8271
8272 } = slot_;
8273 }
8274
8275 let _field = info.as_mut();
8276
8277 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
8278
8279 Ok(())
8280 }
8281 }
8282
8283 impl<'de> ::fidl_next::IntoNatural for DebugGetHostBridgeInfoResponse<'de> {
8284 type Natural = crate::natural::DebugGetHostBridgeInfoResponse;
8285 }
8286
8287 #[derive(Clone, Debug)]
8289 #[repr(C)]
8290 pub struct ExtendedCapability {
8291 pub id: ::fidl_next::wire::Uint16,
8292
8293 pub offset: ::fidl_next::wire::Uint16,
8294 }
8295
8296 static_assertions::const_assert_eq!(std::mem::size_of::<ExtendedCapability>(), 4);
8297 static_assertions::const_assert_eq!(std::mem::align_of::<ExtendedCapability>(), 2);
8298
8299 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, id), 0);
8300
8301 static_assertions::const_assert_eq!(std::mem::offset_of!(ExtendedCapability, offset), 2);
8302
8303 impl ::fidl_next::Constrained for ExtendedCapability {
8304 type Constraint = ();
8305
8306 fn validate(
8307 _: ::fidl_next::Slot<'_, Self>,
8308 _: Self::Constraint,
8309 ) -> Result<(), ::fidl_next::ValidationError> {
8310 Ok(())
8311 }
8312 }
8313
8314 unsafe impl ::fidl_next::Wire for ExtendedCapability {
8315 type Narrowed<'de> = ExtendedCapability;
8316
8317 #[inline]
8318 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8319 ::fidl_next::munge! {
8320 let Self {
8321 id,
8322 offset,
8323
8324 } = &mut *out_;
8325 }
8326
8327 ::fidl_next::Wire::zero_padding(id);
8328
8329 ::fidl_next::Wire::zero_padding(offset);
8330 }
8331 }
8332
8333 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapability
8334 where
8335 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8336 {
8337 fn decode(
8338 slot_: ::fidl_next::Slot<'_, Self>,
8339 decoder_: &mut ___D,
8340 _: (),
8341 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8342 ::fidl_next::munge! {
8343 let Self {
8344 mut id,
8345 mut offset,
8346
8347 } = slot_;
8348 }
8349
8350 let _field = id.as_mut();
8351
8352 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
8353
8354 let _field = offset.as_mut();
8355
8356 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8357
8358 Ok(())
8359 }
8360 }
8361
8362 impl ::fidl_next::IntoNatural for ExtendedCapability {
8363 type Natural = crate::natural::ExtendedCapability;
8364 }
8365
8366 #[derive(Debug)]
8368 #[repr(C)]
8369 pub struct PciDevice<'de> {
8370 pub base_addresses: ::fidl_next::wire::Vector<'de, crate::wire::BaseAddress>,
8371
8372 pub capabilities: ::fidl_next::wire::Vector<'de, crate::wire::Capability>,
8373
8374 pub ext_capabilities: ::fidl_next::wire::Vector<'de, crate::wire::ExtendedCapability>,
8375
8376 pub config: ::fidl_next::wire::Vector<'de, u8>,
8377
8378 pub bus_id: u8,
8379
8380 pub device_id: u8,
8381
8382 pub function_id: u8,
8383 }
8384
8385 static_assertions::const_assert_eq!(std::mem::size_of::<PciDevice<'_>>(), 72);
8386 static_assertions::const_assert_eq!(std::mem::align_of::<PciDevice<'_>>(), 8);
8387
8388 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, base_addresses), 0);
8389
8390 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, capabilities), 16);
8391
8392 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, ext_capabilities), 32);
8393
8394 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, config), 48);
8395
8396 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, bus_id), 64);
8397
8398 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, device_id), 65);
8399
8400 static_assertions::const_assert_eq!(std::mem::offset_of!(PciDevice<'_>, function_id), 66);
8401
8402 impl ::fidl_next::Constrained for PciDevice<'_> {
8403 type Constraint = ();
8404
8405 fn validate(
8406 _: ::fidl_next::Slot<'_, Self>,
8407 _: Self::Constraint,
8408 ) -> Result<(), ::fidl_next::ValidationError> {
8409 Ok(())
8410 }
8411 }
8412
8413 unsafe impl ::fidl_next::Wire for PciDevice<'static> {
8414 type Narrowed<'de> = PciDevice<'de>;
8415
8416 #[inline]
8417 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8418 ::fidl_next::munge! {
8419 let Self {
8420 base_addresses,
8421 capabilities,
8422 ext_capabilities,
8423 config,
8424 bus_id,
8425 device_id,
8426 function_id,
8427
8428 } = &mut *out_;
8429 }
8430
8431 ::fidl_next::Wire::zero_padding(base_addresses);
8432
8433 ::fidl_next::Wire::zero_padding(capabilities);
8434
8435 ::fidl_next::Wire::zero_padding(ext_capabilities);
8436
8437 ::fidl_next::Wire::zero_padding(config);
8438
8439 ::fidl_next::Wire::zero_padding(bus_id);
8440
8441 ::fidl_next::Wire::zero_padding(device_id);
8442
8443 ::fidl_next::Wire::zero_padding(function_id);
8444
8445 unsafe {
8446 out_.as_mut_ptr().cast::<u8>().add(67).write_bytes(0, 5);
8447 }
8448 }
8449 }
8450
8451 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PciDevice<'de>
8452 where
8453 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8454 ___D: ::fidl_next::Decoder<'de>,
8455 {
8456 fn decode(
8457 slot_: ::fidl_next::Slot<'_, Self>,
8458 decoder_: &mut ___D,
8459 _: (),
8460 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8461 if slot_.as_bytes()[67..72] != [0u8; 5] {
8462 return Err(::fidl_next::DecodeError::InvalidPadding);
8463 }
8464
8465 ::fidl_next::munge! {
8466 let Self {
8467 mut base_addresses,
8468 mut capabilities,
8469 mut ext_capabilities,
8470 mut config,
8471 mut bus_id,
8472 mut device_id,
8473 mut function_id,
8474
8475 } = slot_;
8476 }
8477
8478 let _field = base_addresses.as_mut();
8479 ::fidl_next::Constrained::validate(_field, (6, ()))?;
8480 ::fidl_next::Decode::decode(base_addresses.as_mut(), decoder_, (6, ()))?;
8481
8482 let base_addresses = unsafe { base_addresses.deref_unchecked() };
8483
8484 if base_addresses.len() > 6 {
8485 return Err(::fidl_next::DecodeError::VectorTooLong {
8486 size: base_addresses.len() as u64,
8487 limit: 6,
8488 });
8489 }
8490
8491 let _field = capabilities.as_mut();
8492 ::fidl_next::Constrained::validate(_field, (32, ()))?;
8493 ::fidl_next::Decode::decode(capabilities.as_mut(), decoder_, (32, ()))?;
8494
8495 let capabilities = unsafe { capabilities.deref_unchecked() };
8496
8497 if capabilities.len() > 32 {
8498 return Err(::fidl_next::DecodeError::VectorTooLong {
8499 size: capabilities.len() as u64,
8500 limit: 32,
8501 });
8502 }
8503
8504 let _field = ext_capabilities.as_mut();
8505 ::fidl_next::Constrained::validate(_field, (32, ()))?;
8506 ::fidl_next::Decode::decode(ext_capabilities.as_mut(), decoder_, (32, ()))?;
8507
8508 let ext_capabilities = unsafe { ext_capabilities.deref_unchecked() };
8509
8510 if ext_capabilities.len() > 32 {
8511 return Err(::fidl_next::DecodeError::VectorTooLong {
8512 size: ext_capabilities.len() as u64,
8513 limit: 32,
8514 });
8515 }
8516
8517 let _field = config.as_mut();
8518 ::fidl_next::Constrained::validate(_field, (256, ()))?;
8519 ::fidl_next::Decode::decode(config.as_mut(), decoder_, (256, ()))?;
8520
8521 let config = unsafe { config.deref_unchecked() };
8522
8523 if config.len() > 256 {
8524 return Err(::fidl_next::DecodeError::VectorTooLong {
8525 size: config.len() as u64,
8526 limit: 256,
8527 });
8528 }
8529
8530 let _field = bus_id.as_mut();
8531
8532 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
8533
8534 let _field = device_id.as_mut();
8535
8536 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
8537
8538 let _field = function_id.as_mut();
8539
8540 ::fidl_next::Decode::decode(function_id.as_mut(), decoder_, ())?;
8541
8542 Ok(())
8543 }
8544 }
8545
8546 impl<'de> ::fidl_next::IntoNatural for PciDevice<'de> {
8547 type Natural = crate::natural::PciDevice;
8548 }
8549
8550 #[derive(Debug)]
8552 #[repr(C)]
8553 pub struct DebugGetDevicesResponse<'de> {
8554 pub devices: ::fidl_next::wire::Vector<'de, crate::wire::PciDevice<'de>>,
8555 }
8556
8557 static_assertions::const_assert_eq!(std::mem::size_of::<DebugGetDevicesResponse<'_>>(), 16);
8558 static_assertions::const_assert_eq!(std::mem::align_of::<DebugGetDevicesResponse<'_>>(), 8);
8559
8560 static_assertions::const_assert_eq!(
8561 std::mem::offset_of!(DebugGetDevicesResponse<'_>, devices),
8562 0
8563 );
8564
8565 impl ::fidl_next::Constrained for DebugGetDevicesResponse<'_> {
8566 type Constraint = ();
8567
8568 fn validate(
8569 _: ::fidl_next::Slot<'_, Self>,
8570 _: Self::Constraint,
8571 ) -> Result<(), ::fidl_next::ValidationError> {
8572 Ok(())
8573 }
8574 }
8575
8576 unsafe impl ::fidl_next::Wire for DebugGetDevicesResponse<'static> {
8577 type Narrowed<'de> = DebugGetDevicesResponse<'de>;
8578
8579 #[inline]
8580 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8581 ::fidl_next::munge! {
8582 let Self {
8583 devices,
8584
8585 } = &mut *out_;
8586 }
8587
8588 ::fidl_next::Wire::zero_padding(devices);
8589 }
8590 }
8591
8592 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugGetDevicesResponse<'de>
8593 where
8594 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8595 ___D: ::fidl_next::Decoder<'de>,
8596 {
8597 fn decode(
8598 slot_: ::fidl_next::Slot<'_, Self>,
8599 decoder_: &mut ___D,
8600 _: (),
8601 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8602 ::fidl_next::munge! {
8603 let Self {
8604 mut devices,
8605
8606 } = slot_;
8607 }
8608
8609 let _field = devices.as_mut();
8610 ::fidl_next::Constrained::validate(_field, (64, ()))?;
8611 ::fidl_next::Decode::decode(devices.as_mut(), decoder_, (64, ()))?;
8612
8613 let devices = unsafe { devices.deref_unchecked() };
8614
8615 if devices.len() > 64 {
8616 return Err(::fidl_next::DecodeError::VectorTooLong {
8617 size: devices.len() as u64,
8618 limit: 64,
8619 });
8620 }
8621
8622 Ok(())
8623 }
8624 }
8625
8626 impl<'de> ::fidl_next::IntoNatural for DebugGetDevicesResponse<'de> {
8627 type Natural = crate::natural::DebugGetDevicesResponse;
8628 }
8629
8630 #[derive(Clone, Debug)]
8632 #[repr(C)]
8633 pub struct DebugReadBarRequest {
8634 pub device: crate::wire::Address,
8635
8636 pub bar_id: u8,
8637
8638 pub offset: ::fidl_next::wire::Uint64,
8639
8640 pub size: ::fidl_next::wire::Uint64,
8641 }
8642
8643 static_assertions::const_assert_eq!(std::mem::size_of::<DebugReadBarRequest>(), 24);
8644 static_assertions::const_assert_eq!(std::mem::align_of::<DebugReadBarRequest>(), 8);
8645
8646 static_assertions::const_assert_eq!(std::mem::offset_of!(DebugReadBarRequest, device), 0);
8647
8648 static_assertions::const_assert_eq!(std::mem::offset_of!(DebugReadBarRequest, bar_id), 3);
8649
8650 static_assertions::const_assert_eq!(std::mem::offset_of!(DebugReadBarRequest, offset), 8);
8651
8652 static_assertions::const_assert_eq!(std::mem::offset_of!(DebugReadBarRequest, size), 16);
8653
8654 impl ::fidl_next::Constrained for DebugReadBarRequest {
8655 type Constraint = ();
8656
8657 fn validate(
8658 _: ::fidl_next::Slot<'_, Self>,
8659 _: Self::Constraint,
8660 ) -> Result<(), ::fidl_next::ValidationError> {
8661 Ok(())
8662 }
8663 }
8664
8665 unsafe impl ::fidl_next::Wire for DebugReadBarRequest {
8666 type Narrowed<'de> = DebugReadBarRequest;
8667
8668 #[inline]
8669 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8670 ::fidl_next::munge! {
8671 let Self {
8672 device,
8673 bar_id,
8674 offset,
8675 size,
8676
8677 } = &mut *out_;
8678 }
8679
8680 ::fidl_next::Wire::zero_padding(device);
8681
8682 ::fidl_next::Wire::zero_padding(bar_id);
8683
8684 ::fidl_next::Wire::zero_padding(offset);
8685
8686 ::fidl_next::Wire::zero_padding(size);
8687
8688 unsafe {
8689 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
8690 }
8691 }
8692 }
8693
8694 unsafe impl<___D> ::fidl_next::Decode<___D> for DebugReadBarRequest
8695 where
8696 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8697 {
8698 fn decode(
8699 slot_: ::fidl_next::Slot<'_, Self>,
8700 decoder_: &mut ___D,
8701 _: (),
8702 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8703 if slot_.as_bytes()[4..8] != [0u8; 4] {
8704 return Err(::fidl_next::DecodeError::InvalidPadding);
8705 }
8706
8707 ::fidl_next::munge! {
8708 let Self {
8709 mut device,
8710 mut bar_id,
8711 mut offset,
8712 mut size,
8713
8714 } = slot_;
8715 }
8716
8717 let _field = device.as_mut();
8718
8719 ::fidl_next::Decode::decode(device.as_mut(), decoder_, ())?;
8720
8721 let _field = bar_id.as_mut();
8722
8723 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
8724
8725 let _field = offset.as_mut();
8726
8727 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8728
8729 let _field = size.as_mut();
8730
8731 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8732
8733 Ok(())
8734 }
8735 }
8736
8737 impl ::fidl_next::IntoNatural for DebugReadBarRequest {
8738 type Natural = crate::natural::DebugReadBarRequest;
8739 }
8740
8741 #[derive(Debug)]
8743 #[repr(C)]
8744 pub struct DebugReadBarResponse<'de> {
8745 pub buffer: ::fidl_next::wire::Vector<'de, u8>,
8746 }
8747
8748 static_assertions::const_assert_eq!(std::mem::size_of::<DebugReadBarResponse<'_>>(), 16);
8749 static_assertions::const_assert_eq!(std::mem::align_of::<DebugReadBarResponse<'_>>(), 8);
8750
8751 static_assertions::const_assert_eq!(std::mem::offset_of!(DebugReadBarResponse<'_>, buffer), 0);
8752
8753 impl ::fidl_next::Constrained for DebugReadBarResponse<'_> {
8754 type Constraint = ();
8755
8756 fn validate(
8757 _: ::fidl_next::Slot<'_, Self>,
8758 _: Self::Constraint,
8759 ) -> Result<(), ::fidl_next::ValidationError> {
8760 Ok(())
8761 }
8762 }
8763
8764 unsafe impl ::fidl_next::Wire for DebugReadBarResponse<'static> {
8765 type Narrowed<'de> = DebugReadBarResponse<'de>;
8766
8767 #[inline]
8768 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8769 ::fidl_next::munge! {
8770 let Self {
8771 buffer,
8772
8773 } = &mut *out_;
8774 }
8775
8776 ::fidl_next::Wire::zero_padding(buffer);
8777 }
8778 }
8779
8780 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugReadBarResponse<'de>
8781 where
8782 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8783 ___D: ::fidl_next::Decoder<'de>,
8784 {
8785 fn decode(
8786 slot_: ::fidl_next::Slot<'_, Self>,
8787 decoder_: &mut ___D,
8788 _: (),
8789 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8790 ::fidl_next::munge! {
8791 let Self {
8792 mut buffer,
8793
8794 } = slot_;
8795 }
8796
8797 let _field = buffer.as_mut();
8798 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
8799 ::fidl_next::Decode::decode(buffer.as_mut(), decoder_, (4294967295, ()))?;
8800
8801 Ok(())
8802 }
8803 }
8804
8805 impl<'de> ::fidl_next::IntoNatural for DebugReadBarResponse<'de> {
8806 type Natural = crate::natural::DebugReadBarResponse;
8807 }
8808
8809 pub type Padding = ::fidl_next::wire::Unit;
8811
8812 #[derive(Clone, Debug)]
8814 #[repr(C)]
8815 pub struct DeviceInfo {
8816 pub vendor_id: ::fidl_next::wire::Uint16,
8817
8818 pub device_id: ::fidl_next::wire::Uint16,
8819
8820 pub base_class: u8,
8821
8822 pub sub_class: u8,
8823
8824 pub program_interface: u8,
8825
8826 pub revision_id: u8,
8827
8828 pub bus_id: u8,
8829
8830 pub dev_id: u8,
8831
8832 pub func_id: u8,
8833
8834 pub padding: crate::wire::Padding,
8835 }
8836
8837 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceInfo>(), 12);
8838 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceInfo>(), 2);
8839
8840 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, vendor_id), 0);
8841
8842 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, device_id), 2);
8843
8844 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, base_class), 4);
8845
8846 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, sub_class), 5);
8847
8848 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, program_interface), 6);
8849
8850 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, revision_id), 7);
8851
8852 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, bus_id), 8);
8853
8854 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, dev_id), 9);
8855
8856 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, func_id), 10);
8857
8858 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceInfo, padding), 11);
8859
8860 impl ::fidl_next::Constrained for DeviceInfo {
8861 type Constraint = ();
8862
8863 fn validate(
8864 _: ::fidl_next::Slot<'_, Self>,
8865 _: Self::Constraint,
8866 ) -> Result<(), ::fidl_next::ValidationError> {
8867 Ok(())
8868 }
8869 }
8870
8871 unsafe impl ::fidl_next::Wire for DeviceInfo {
8872 type Narrowed<'de> = DeviceInfo;
8873
8874 #[inline]
8875 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8876 ::fidl_next::munge! {
8877 let Self {
8878 vendor_id,
8879 device_id,
8880 base_class,
8881 sub_class,
8882 program_interface,
8883 revision_id,
8884 bus_id,
8885 dev_id,
8886 func_id,
8887 padding,
8888
8889 } = &mut *out_;
8890 }
8891
8892 ::fidl_next::Wire::zero_padding(vendor_id);
8893
8894 ::fidl_next::Wire::zero_padding(device_id);
8895
8896 ::fidl_next::Wire::zero_padding(base_class);
8897
8898 ::fidl_next::Wire::zero_padding(sub_class);
8899
8900 ::fidl_next::Wire::zero_padding(program_interface);
8901
8902 ::fidl_next::Wire::zero_padding(revision_id);
8903
8904 ::fidl_next::Wire::zero_padding(bus_id);
8905
8906 ::fidl_next::Wire::zero_padding(dev_id);
8907
8908 ::fidl_next::Wire::zero_padding(func_id);
8909
8910 ::fidl_next::Wire::zero_padding(padding);
8911 }
8912 }
8913
8914 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceInfo
8915 where
8916 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8917 {
8918 fn decode(
8919 slot_: ::fidl_next::Slot<'_, Self>,
8920 decoder_: &mut ___D,
8921 _: (),
8922 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8923 ::fidl_next::munge! {
8924 let Self {
8925 mut vendor_id,
8926 mut device_id,
8927 mut base_class,
8928 mut sub_class,
8929 mut program_interface,
8930 mut revision_id,
8931 mut bus_id,
8932 mut dev_id,
8933 mut func_id,
8934 mut padding,
8935
8936 } = slot_;
8937 }
8938
8939 let _field = vendor_id.as_mut();
8940
8941 ::fidl_next::Decode::decode(vendor_id.as_mut(), decoder_, ())?;
8942
8943 let _field = device_id.as_mut();
8944
8945 ::fidl_next::Decode::decode(device_id.as_mut(), decoder_, ())?;
8946
8947 let _field = base_class.as_mut();
8948
8949 ::fidl_next::Decode::decode(base_class.as_mut(), decoder_, ())?;
8950
8951 let _field = sub_class.as_mut();
8952
8953 ::fidl_next::Decode::decode(sub_class.as_mut(), decoder_, ())?;
8954
8955 let _field = program_interface.as_mut();
8956
8957 ::fidl_next::Decode::decode(program_interface.as_mut(), decoder_, ())?;
8958
8959 let _field = revision_id.as_mut();
8960
8961 ::fidl_next::Decode::decode(revision_id.as_mut(), decoder_, ())?;
8962
8963 let _field = bus_id.as_mut();
8964
8965 ::fidl_next::Decode::decode(bus_id.as_mut(), decoder_, ())?;
8966
8967 let _field = dev_id.as_mut();
8968
8969 ::fidl_next::Decode::decode(dev_id.as_mut(), decoder_, ())?;
8970
8971 let _field = func_id.as_mut();
8972
8973 ::fidl_next::Decode::decode(func_id.as_mut(), decoder_, ())?;
8974
8975 let _field = padding.as_mut();
8976
8977 ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
8978
8979 Ok(())
8980 }
8981 }
8982
8983 impl ::fidl_next::IntoNatural for DeviceInfo {
8984 type Natural = crate::natural::DeviceInfo;
8985 }
8986
8987 #[derive(Clone, Debug)]
8989 #[repr(C)]
8990 pub struct DeviceGetDeviceInfoResponse {
8991 pub info: crate::wire::DeviceInfo,
8992 }
8993
8994 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetDeviceInfoResponse>(), 12);
8995 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetDeviceInfoResponse>(), 2);
8996
8997 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetDeviceInfoResponse, info), 0);
8998
8999 impl ::fidl_next::Constrained for DeviceGetDeviceInfoResponse {
9000 type Constraint = ();
9001
9002 fn validate(
9003 _: ::fidl_next::Slot<'_, Self>,
9004 _: Self::Constraint,
9005 ) -> Result<(), ::fidl_next::ValidationError> {
9006 Ok(())
9007 }
9008 }
9009
9010 unsafe impl ::fidl_next::Wire for DeviceGetDeviceInfoResponse {
9011 type Narrowed<'de> = DeviceGetDeviceInfoResponse;
9012
9013 #[inline]
9014 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9015 ::fidl_next::munge! {
9016 let Self {
9017 info,
9018
9019 } = &mut *out_;
9020 }
9021
9022 ::fidl_next::Wire::zero_padding(info);
9023 }
9024 }
9025
9026 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetDeviceInfoResponse
9027 where
9028 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9029 {
9030 fn decode(
9031 slot_: ::fidl_next::Slot<'_, Self>,
9032 decoder_: &mut ___D,
9033 _: (),
9034 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9035 ::fidl_next::munge! {
9036 let Self {
9037 mut info,
9038
9039 } = slot_;
9040 }
9041
9042 let _field = info.as_mut();
9043
9044 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
9045
9046 Ok(())
9047 }
9048 }
9049
9050 impl ::fidl_next::IntoNatural for DeviceGetDeviceInfoResponse {
9051 type Natural = crate::natural::DeviceGetDeviceInfoResponse;
9052 }
9053
9054 #[derive(Clone, Debug)]
9056 #[repr(C)]
9057 pub struct DeviceGetBarRequest {
9058 pub bar_id: ::fidl_next::wire::Uint32,
9059 }
9060
9061 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBarRequest>(), 4);
9062 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBarRequest>(), 4);
9063
9064 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBarRequest, bar_id), 0);
9065
9066 impl ::fidl_next::Constrained for DeviceGetBarRequest {
9067 type Constraint = ();
9068
9069 fn validate(
9070 _: ::fidl_next::Slot<'_, Self>,
9071 _: Self::Constraint,
9072 ) -> Result<(), ::fidl_next::ValidationError> {
9073 Ok(())
9074 }
9075 }
9076
9077 unsafe impl ::fidl_next::Wire for DeviceGetBarRequest {
9078 type Narrowed<'de> = DeviceGetBarRequest;
9079
9080 #[inline]
9081 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9082 ::fidl_next::munge! {
9083 let Self {
9084 bar_id,
9085
9086 } = &mut *out_;
9087 }
9088
9089 ::fidl_next::Wire::zero_padding(bar_id);
9090 }
9091 }
9092
9093 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBarRequest
9094 where
9095 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9096 {
9097 fn decode(
9098 slot_: ::fidl_next::Slot<'_, Self>,
9099 decoder_: &mut ___D,
9100 _: (),
9101 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9102 ::fidl_next::munge! {
9103 let Self {
9104 mut bar_id,
9105
9106 } = slot_;
9107 }
9108
9109 let _field = bar_id.as_mut();
9110
9111 ::fidl_next::Decode::decode(bar_id.as_mut(), decoder_, ())?;
9112
9113 Ok(())
9114 }
9115 }
9116
9117 impl ::fidl_next::IntoNatural for DeviceGetBarRequest {
9118 type Natural = crate::natural::DeviceGetBarRequest;
9119 }
9120
9121 #[derive(Clone, Debug)]
9123 #[repr(C)]
9124 pub struct DeviceSetBusMasteringRequest {
9125 pub enabled: bool,
9126 }
9127
9128 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetBusMasteringRequest>(), 1);
9129 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetBusMasteringRequest>(), 1);
9130
9131 static_assertions::const_assert_eq!(
9132 std::mem::offset_of!(DeviceSetBusMasteringRequest, enabled),
9133 0
9134 );
9135
9136 impl ::fidl_next::Constrained for DeviceSetBusMasteringRequest {
9137 type Constraint = ();
9138
9139 fn validate(
9140 _: ::fidl_next::Slot<'_, Self>,
9141 _: Self::Constraint,
9142 ) -> Result<(), ::fidl_next::ValidationError> {
9143 Ok(())
9144 }
9145 }
9146
9147 unsafe impl ::fidl_next::Wire for DeviceSetBusMasteringRequest {
9148 type Narrowed<'de> = DeviceSetBusMasteringRequest;
9149
9150 #[inline]
9151 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9152 ::fidl_next::munge! {
9153 let Self {
9154 enabled,
9155
9156 } = &mut *out_;
9157 }
9158
9159 ::fidl_next::Wire::zero_padding(enabled);
9160 }
9161 }
9162
9163 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetBusMasteringRequest
9164 where
9165 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9166 {
9167 fn decode(
9168 slot_: ::fidl_next::Slot<'_, Self>,
9169 decoder_: &mut ___D,
9170 _: (),
9171 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9172 ::fidl_next::munge! {
9173 let Self {
9174 mut enabled,
9175
9176 } = slot_;
9177 }
9178
9179 let _field = enabled.as_mut();
9180
9181 ::fidl_next::Decode::decode(enabled.as_mut(), decoder_, ())?;
9182
9183 Ok(())
9184 }
9185 }
9186
9187 impl ::fidl_next::IntoNatural for DeviceSetBusMasteringRequest {
9188 type Natural = crate::natural::DeviceSetBusMasteringRequest;
9189 }
9190
9191 pub type DeviceSetBusMasteringResponse = ::fidl_next::wire::Unit;
9193
9194 pub type DeviceResetDeviceResponse = ::fidl_next::wire::Unit;
9196
9197 pub type DeviceAckInterruptResponse = ::fidl_next::wire::Unit;
9199
9200 #[derive(Clone, Debug)]
9202 #[repr(C)]
9203 pub struct DeviceMapInterruptRequest {
9204 pub which_irq: ::fidl_next::wire::Uint32,
9205 }
9206
9207 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceMapInterruptRequest>(), 4);
9208 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceMapInterruptRequest>(), 4);
9209
9210 static_assertions::const_assert_eq!(
9211 std::mem::offset_of!(DeviceMapInterruptRequest, which_irq),
9212 0
9213 );
9214
9215 impl ::fidl_next::Constrained for DeviceMapInterruptRequest {
9216 type Constraint = ();
9217
9218 fn validate(
9219 _: ::fidl_next::Slot<'_, Self>,
9220 _: Self::Constraint,
9221 ) -> Result<(), ::fidl_next::ValidationError> {
9222 Ok(())
9223 }
9224 }
9225
9226 unsafe impl ::fidl_next::Wire for DeviceMapInterruptRequest {
9227 type Narrowed<'de> = DeviceMapInterruptRequest;
9228
9229 #[inline]
9230 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9231 ::fidl_next::munge! {
9232 let Self {
9233 which_irq,
9234
9235 } = &mut *out_;
9236 }
9237
9238 ::fidl_next::Wire::zero_padding(which_irq);
9239 }
9240 }
9241
9242 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceMapInterruptRequest
9243 where
9244 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9245 {
9246 fn decode(
9247 slot_: ::fidl_next::Slot<'_, Self>,
9248 decoder_: &mut ___D,
9249 _: (),
9250 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9251 ::fidl_next::munge! {
9252 let Self {
9253 mut which_irq,
9254
9255 } = slot_;
9256 }
9257
9258 let _field = which_irq.as_mut();
9259
9260 ::fidl_next::Decode::decode(which_irq.as_mut(), decoder_, ())?;
9261
9262 Ok(())
9263 }
9264 }
9265
9266 impl ::fidl_next::IntoNatural for DeviceMapInterruptRequest {
9267 type Natural = crate::natural::DeviceMapInterruptRequest;
9268 }
9269
9270 #[derive(Clone, Debug)]
9272 #[repr(C)]
9273 pub struct InterruptModes {
9274 pub has_legacy: bool,
9275
9276 pub msi_count: u8,
9277
9278 pub msix_count: ::fidl_next::wire::Uint16,
9279 }
9280
9281 static_assertions::const_assert_eq!(std::mem::size_of::<InterruptModes>(), 4);
9282 static_assertions::const_assert_eq!(std::mem::align_of::<InterruptModes>(), 2);
9283
9284 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, has_legacy), 0);
9285
9286 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msi_count), 1);
9287
9288 static_assertions::const_assert_eq!(std::mem::offset_of!(InterruptModes, msix_count), 2);
9289
9290 impl ::fidl_next::Constrained for InterruptModes {
9291 type Constraint = ();
9292
9293 fn validate(
9294 _: ::fidl_next::Slot<'_, Self>,
9295 _: Self::Constraint,
9296 ) -> Result<(), ::fidl_next::ValidationError> {
9297 Ok(())
9298 }
9299 }
9300
9301 unsafe impl ::fidl_next::Wire for InterruptModes {
9302 type Narrowed<'de> = InterruptModes;
9303
9304 #[inline]
9305 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9306 ::fidl_next::munge! {
9307 let Self {
9308 has_legacy,
9309 msi_count,
9310 msix_count,
9311
9312 } = &mut *out_;
9313 }
9314
9315 ::fidl_next::Wire::zero_padding(has_legacy);
9316
9317 ::fidl_next::Wire::zero_padding(msi_count);
9318
9319 ::fidl_next::Wire::zero_padding(msix_count);
9320 }
9321 }
9322
9323 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptModes
9324 where
9325 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9326 {
9327 fn decode(
9328 slot_: ::fidl_next::Slot<'_, Self>,
9329 decoder_: &mut ___D,
9330 _: (),
9331 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9332 ::fidl_next::munge! {
9333 let Self {
9334 mut has_legacy,
9335 mut msi_count,
9336 mut msix_count,
9337
9338 } = slot_;
9339 }
9340
9341 let _field = has_legacy.as_mut();
9342
9343 ::fidl_next::Decode::decode(has_legacy.as_mut(), decoder_, ())?;
9344
9345 let _field = msi_count.as_mut();
9346
9347 ::fidl_next::Decode::decode(msi_count.as_mut(), decoder_, ())?;
9348
9349 let _field = msix_count.as_mut();
9350
9351 ::fidl_next::Decode::decode(msix_count.as_mut(), decoder_, ())?;
9352
9353 Ok(())
9354 }
9355 }
9356
9357 impl ::fidl_next::IntoNatural for InterruptModes {
9358 type Natural = crate::natural::InterruptModes;
9359 }
9360
9361 #[derive(Clone, Debug)]
9363 #[repr(C)]
9364 pub struct DeviceGetInterruptModesResponse {
9365 pub modes: crate::wire::InterruptModes,
9366 }
9367
9368 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetInterruptModesResponse>(), 4);
9369 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetInterruptModesResponse>(), 2);
9370
9371 static_assertions::const_assert_eq!(
9372 std::mem::offset_of!(DeviceGetInterruptModesResponse, modes),
9373 0
9374 );
9375
9376 impl ::fidl_next::Constrained for DeviceGetInterruptModesResponse {
9377 type Constraint = ();
9378
9379 fn validate(
9380 _: ::fidl_next::Slot<'_, Self>,
9381 _: Self::Constraint,
9382 ) -> Result<(), ::fidl_next::ValidationError> {
9383 Ok(())
9384 }
9385 }
9386
9387 unsafe impl ::fidl_next::Wire for DeviceGetInterruptModesResponse {
9388 type Narrowed<'de> = DeviceGetInterruptModesResponse;
9389
9390 #[inline]
9391 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9392 ::fidl_next::munge! {
9393 let Self {
9394 modes,
9395
9396 } = &mut *out_;
9397 }
9398
9399 ::fidl_next::Wire::zero_padding(modes);
9400 }
9401 }
9402
9403 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetInterruptModesResponse
9404 where
9405 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9406 {
9407 fn decode(
9408 slot_: ::fidl_next::Slot<'_, Self>,
9409 decoder_: &mut ___D,
9410 _: (),
9411 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9412 ::fidl_next::munge! {
9413 let Self {
9414 mut modes,
9415
9416 } = slot_;
9417 }
9418
9419 let _field = modes.as_mut();
9420
9421 ::fidl_next::Decode::decode(modes.as_mut(), decoder_, ())?;
9422
9423 Ok(())
9424 }
9425 }
9426
9427 impl ::fidl_next::IntoNatural for DeviceGetInterruptModesResponse {
9428 type Natural = crate::natural::DeviceGetInterruptModesResponse;
9429 }
9430
9431 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9433 #[repr(transparent)]
9434 pub struct InterruptMode {
9435 pub(crate) value: u8,
9436 }
9437
9438 impl ::fidl_next::Constrained for InterruptMode {
9439 type Constraint = ();
9440
9441 fn validate(
9442 _: ::fidl_next::Slot<'_, Self>,
9443 _: Self::Constraint,
9444 ) -> Result<(), ::fidl_next::ValidationError> {
9445 Ok(())
9446 }
9447 }
9448
9449 unsafe impl ::fidl_next::Wire for InterruptMode {
9450 type Narrowed<'de> = Self;
9451
9452 #[inline]
9453 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9454 }
9456 }
9457
9458 impl InterruptMode {
9459 pub const DISABLED: InterruptMode = InterruptMode { value: 0 };
9460
9461 pub const LEGACY: InterruptMode = InterruptMode { value: 1 };
9462
9463 pub const MSI: InterruptMode = InterruptMode { value: 2 };
9464
9465 pub const MSI_X: InterruptMode = InterruptMode { value: 3 };
9466 }
9467
9468 unsafe impl<___D> ::fidl_next::Decode<___D> for InterruptMode
9469 where
9470 ___D: ?Sized,
9471 {
9472 fn decode(
9473 slot: ::fidl_next::Slot<'_, Self>,
9474 _: &mut ___D,
9475 _: (),
9476 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9477 ::fidl_next::munge!(let Self { value } = slot);
9478
9479 match u8::from(*value) {
9480 0 | 1 | 2 | 3 => (),
9481 unknown => {
9482 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
9483 }
9484 }
9485
9486 Ok(())
9487 }
9488 }
9489
9490 impl ::core::convert::From<crate::natural::InterruptMode> for InterruptMode {
9491 fn from(natural: crate::natural::InterruptMode) -> Self {
9492 match natural {
9493 crate::natural::InterruptMode::Disabled => InterruptMode::DISABLED,
9494
9495 crate::natural::InterruptMode::Legacy => InterruptMode::LEGACY,
9496
9497 crate::natural::InterruptMode::Msi => InterruptMode::MSI,
9498
9499 crate::natural::InterruptMode::MsiX => InterruptMode::MSI_X,
9500 }
9501 }
9502 }
9503
9504 impl ::fidl_next::IntoNatural for InterruptMode {
9505 type Natural = crate::natural::InterruptMode;
9506 }
9507
9508 #[derive(Clone, Debug)]
9510 #[repr(C)]
9511 pub struct DeviceSetInterruptModeRequest {
9512 pub mode: crate::wire::InterruptMode,
9513
9514 pub requested_irq_count: ::fidl_next::wire::Uint32,
9515 }
9516
9517 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSetInterruptModeRequest>(), 8);
9518 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSetInterruptModeRequest>(), 4);
9519
9520 static_assertions::const_assert_eq!(
9521 std::mem::offset_of!(DeviceSetInterruptModeRequest, mode),
9522 0
9523 );
9524
9525 static_assertions::const_assert_eq!(
9526 std::mem::offset_of!(DeviceSetInterruptModeRequest, requested_irq_count),
9527 4
9528 );
9529
9530 impl ::fidl_next::Constrained for DeviceSetInterruptModeRequest {
9531 type Constraint = ();
9532
9533 fn validate(
9534 _: ::fidl_next::Slot<'_, Self>,
9535 _: Self::Constraint,
9536 ) -> Result<(), ::fidl_next::ValidationError> {
9537 Ok(())
9538 }
9539 }
9540
9541 unsafe impl ::fidl_next::Wire for DeviceSetInterruptModeRequest {
9542 type Narrowed<'de> = DeviceSetInterruptModeRequest;
9543
9544 #[inline]
9545 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9546 ::fidl_next::munge! {
9547 let Self {
9548 mode,
9549 requested_irq_count,
9550
9551 } = &mut *out_;
9552 }
9553
9554 ::fidl_next::Wire::zero_padding(mode);
9555
9556 ::fidl_next::Wire::zero_padding(requested_irq_count);
9557
9558 unsafe {
9559 out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
9560 }
9561 }
9562 }
9563
9564 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSetInterruptModeRequest
9565 where
9566 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9567 {
9568 fn decode(
9569 slot_: ::fidl_next::Slot<'_, Self>,
9570 decoder_: &mut ___D,
9571 _: (),
9572 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9573 if slot_.as_bytes()[1..4] != [0u8; 3] {
9574 return Err(::fidl_next::DecodeError::InvalidPadding);
9575 }
9576
9577 ::fidl_next::munge! {
9578 let Self {
9579 mut mode,
9580 mut requested_irq_count,
9581
9582 } = slot_;
9583 }
9584
9585 let _field = mode.as_mut();
9586
9587 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
9588
9589 let _field = requested_irq_count.as_mut();
9590
9591 ::fidl_next::Decode::decode(requested_irq_count.as_mut(), decoder_, ())?;
9592
9593 Ok(())
9594 }
9595 }
9596
9597 impl ::fidl_next::IntoNatural for DeviceSetInterruptModeRequest {
9598 type Natural = crate::natural::DeviceSetInterruptModeRequest;
9599 }
9600
9601 pub type DeviceSetInterruptModeResponse = ::fidl_next::wire::Unit;
9603
9604 pub type ExtendedConfigOffset = ::fidl_next::wire::Uint16;
9606
9607 #[derive(Clone, Debug)]
9609 #[repr(C)]
9610 pub struct DeviceReadConfig8Request {
9611 pub offset: ::fidl_next::wire::Uint16,
9612 }
9613
9614 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Request>(), 2);
9615 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Request>(), 2);
9616
9617 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Request, offset), 0);
9618
9619 impl ::fidl_next::Constrained for DeviceReadConfig8Request {
9620 type Constraint = ();
9621
9622 fn validate(
9623 _: ::fidl_next::Slot<'_, Self>,
9624 _: Self::Constraint,
9625 ) -> Result<(), ::fidl_next::ValidationError> {
9626 Ok(())
9627 }
9628 }
9629
9630 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Request {
9631 type Narrowed<'de> = DeviceReadConfig8Request;
9632
9633 #[inline]
9634 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9635 ::fidl_next::munge! {
9636 let Self {
9637 offset,
9638
9639 } = &mut *out_;
9640 }
9641
9642 ::fidl_next::Wire::zero_padding(offset);
9643 }
9644 }
9645
9646 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Request
9647 where
9648 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9649 {
9650 fn decode(
9651 slot_: ::fidl_next::Slot<'_, Self>,
9652 decoder_: &mut ___D,
9653 _: (),
9654 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9655 ::fidl_next::munge! {
9656 let Self {
9657 mut offset,
9658
9659 } = slot_;
9660 }
9661
9662 let _field = offset.as_mut();
9663
9664 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9665
9666 Ok(())
9667 }
9668 }
9669
9670 impl ::fidl_next::IntoNatural for DeviceReadConfig8Request {
9671 type Natural = crate::natural::DeviceReadConfig8Request;
9672 }
9673
9674 #[derive(Clone, Debug)]
9676 #[repr(C)]
9677 pub struct DeviceReadConfig8Response {
9678 pub value: u8,
9679 }
9680
9681 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig8Response>(), 1);
9682 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig8Response>(), 1);
9683
9684 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig8Response, value), 0);
9685
9686 impl ::fidl_next::Constrained for DeviceReadConfig8Response {
9687 type Constraint = ();
9688
9689 fn validate(
9690 _: ::fidl_next::Slot<'_, Self>,
9691 _: Self::Constraint,
9692 ) -> Result<(), ::fidl_next::ValidationError> {
9693 Ok(())
9694 }
9695 }
9696
9697 unsafe impl ::fidl_next::Wire for DeviceReadConfig8Response {
9698 type Narrowed<'de> = DeviceReadConfig8Response;
9699
9700 #[inline]
9701 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9702 ::fidl_next::munge! {
9703 let Self {
9704 value,
9705
9706 } = &mut *out_;
9707 }
9708
9709 ::fidl_next::Wire::zero_padding(value);
9710 }
9711 }
9712
9713 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig8Response
9714 where
9715 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9716 {
9717 fn decode(
9718 slot_: ::fidl_next::Slot<'_, Self>,
9719 decoder_: &mut ___D,
9720 _: (),
9721 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9722 ::fidl_next::munge! {
9723 let Self {
9724 mut value,
9725
9726 } = slot_;
9727 }
9728
9729 let _field = value.as_mut();
9730
9731 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9732
9733 Ok(())
9734 }
9735 }
9736
9737 impl ::fidl_next::IntoNatural for DeviceReadConfig8Response {
9738 type Natural = crate::natural::DeviceReadConfig8Response;
9739 }
9740
9741 #[derive(Clone, Debug)]
9743 #[repr(C)]
9744 pub struct DeviceReadConfig16Request {
9745 pub offset: ::fidl_next::wire::Uint16,
9746 }
9747
9748 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Request>(), 2);
9749 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Request>(), 2);
9750
9751 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Request, offset), 0);
9752
9753 impl ::fidl_next::Constrained for DeviceReadConfig16Request {
9754 type Constraint = ();
9755
9756 fn validate(
9757 _: ::fidl_next::Slot<'_, Self>,
9758 _: Self::Constraint,
9759 ) -> Result<(), ::fidl_next::ValidationError> {
9760 Ok(())
9761 }
9762 }
9763
9764 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Request {
9765 type Narrowed<'de> = DeviceReadConfig16Request;
9766
9767 #[inline]
9768 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9769 ::fidl_next::munge! {
9770 let Self {
9771 offset,
9772
9773 } = &mut *out_;
9774 }
9775
9776 ::fidl_next::Wire::zero_padding(offset);
9777 }
9778 }
9779
9780 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Request
9781 where
9782 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9783 {
9784 fn decode(
9785 slot_: ::fidl_next::Slot<'_, Self>,
9786 decoder_: &mut ___D,
9787 _: (),
9788 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9789 ::fidl_next::munge! {
9790 let Self {
9791 mut offset,
9792
9793 } = slot_;
9794 }
9795
9796 let _field = offset.as_mut();
9797
9798 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9799
9800 Ok(())
9801 }
9802 }
9803
9804 impl ::fidl_next::IntoNatural for DeviceReadConfig16Request {
9805 type Natural = crate::natural::DeviceReadConfig16Request;
9806 }
9807
9808 #[derive(Clone, Debug)]
9810 #[repr(C)]
9811 pub struct DeviceReadConfig16Response {
9812 pub value: ::fidl_next::wire::Uint16,
9813 }
9814
9815 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig16Response>(), 2);
9816 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig16Response>(), 2);
9817
9818 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig16Response, value), 0);
9819
9820 impl ::fidl_next::Constrained for DeviceReadConfig16Response {
9821 type Constraint = ();
9822
9823 fn validate(
9824 _: ::fidl_next::Slot<'_, Self>,
9825 _: Self::Constraint,
9826 ) -> Result<(), ::fidl_next::ValidationError> {
9827 Ok(())
9828 }
9829 }
9830
9831 unsafe impl ::fidl_next::Wire for DeviceReadConfig16Response {
9832 type Narrowed<'de> = DeviceReadConfig16Response;
9833
9834 #[inline]
9835 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9836 ::fidl_next::munge! {
9837 let Self {
9838 value,
9839
9840 } = &mut *out_;
9841 }
9842
9843 ::fidl_next::Wire::zero_padding(value);
9844 }
9845 }
9846
9847 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig16Response
9848 where
9849 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9850 {
9851 fn decode(
9852 slot_: ::fidl_next::Slot<'_, Self>,
9853 decoder_: &mut ___D,
9854 _: (),
9855 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9856 ::fidl_next::munge! {
9857 let Self {
9858 mut value,
9859
9860 } = slot_;
9861 }
9862
9863 let _field = value.as_mut();
9864
9865 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
9866
9867 Ok(())
9868 }
9869 }
9870
9871 impl ::fidl_next::IntoNatural for DeviceReadConfig16Response {
9872 type Natural = crate::natural::DeviceReadConfig16Response;
9873 }
9874
9875 #[derive(Clone, Debug)]
9877 #[repr(C)]
9878 pub struct DeviceReadConfig32Request {
9879 pub offset: ::fidl_next::wire::Uint16,
9880 }
9881
9882 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Request>(), 2);
9883 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Request>(), 2);
9884
9885 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Request, offset), 0);
9886
9887 impl ::fidl_next::Constrained for DeviceReadConfig32Request {
9888 type Constraint = ();
9889
9890 fn validate(
9891 _: ::fidl_next::Slot<'_, Self>,
9892 _: Self::Constraint,
9893 ) -> Result<(), ::fidl_next::ValidationError> {
9894 Ok(())
9895 }
9896 }
9897
9898 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Request {
9899 type Narrowed<'de> = DeviceReadConfig32Request;
9900
9901 #[inline]
9902 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9903 ::fidl_next::munge! {
9904 let Self {
9905 offset,
9906
9907 } = &mut *out_;
9908 }
9909
9910 ::fidl_next::Wire::zero_padding(offset);
9911 }
9912 }
9913
9914 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Request
9915 where
9916 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9917 {
9918 fn decode(
9919 slot_: ::fidl_next::Slot<'_, Self>,
9920 decoder_: &mut ___D,
9921 _: (),
9922 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9923 ::fidl_next::munge! {
9924 let Self {
9925 mut offset,
9926
9927 } = slot_;
9928 }
9929
9930 let _field = offset.as_mut();
9931
9932 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
9933
9934 Ok(())
9935 }
9936 }
9937
9938 impl ::fidl_next::IntoNatural for DeviceReadConfig32Request {
9939 type Natural = crate::natural::DeviceReadConfig32Request;
9940 }
9941
9942 #[derive(Clone, Debug)]
9944 #[repr(C)]
9945 pub struct DeviceReadConfig32Response {
9946 pub value: ::fidl_next::wire::Uint32,
9947 }
9948
9949 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceReadConfig32Response>(), 4);
9950 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceReadConfig32Response>(), 4);
9951
9952 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceReadConfig32Response, value), 0);
9953
9954 impl ::fidl_next::Constrained for DeviceReadConfig32Response {
9955 type Constraint = ();
9956
9957 fn validate(
9958 _: ::fidl_next::Slot<'_, Self>,
9959 _: Self::Constraint,
9960 ) -> Result<(), ::fidl_next::ValidationError> {
9961 Ok(())
9962 }
9963 }
9964
9965 unsafe impl ::fidl_next::Wire for DeviceReadConfig32Response {
9966 type Narrowed<'de> = DeviceReadConfig32Response;
9967
9968 #[inline]
9969 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9970 ::fidl_next::munge! {
9971 let Self {
9972 value,
9973
9974 } = &mut *out_;
9975 }
9976
9977 ::fidl_next::Wire::zero_padding(value);
9978 }
9979 }
9980
9981 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceReadConfig32Response
9982 where
9983 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9984 {
9985 fn decode(
9986 slot_: ::fidl_next::Slot<'_, Self>,
9987 decoder_: &mut ___D,
9988 _: (),
9989 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9990 ::fidl_next::munge! {
9991 let Self {
9992 mut value,
9993
9994 } = slot_;
9995 }
9996
9997 let _field = value.as_mut();
9998
9999 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10000
10001 Ok(())
10002 }
10003 }
10004
10005 impl ::fidl_next::IntoNatural for DeviceReadConfig32Response {
10006 type Natural = crate::natural::DeviceReadConfig32Response;
10007 }
10008
10009 #[derive(Clone, Debug)]
10011 #[repr(C)]
10012 pub struct DeviceWriteConfig8Request {
10013 pub offset: ::fidl_next::wire::Uint16,
10014
10015 pub value: u8,
10016 }
10017
10018 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig8Request>(), 4);
10019 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig8Request>(), 2);
10020
10021 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, offset), 0);
10022
10023 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig8Request, value), 2);
10024
10025 impl ::fidl_next::Constrained for DeviceWriteConfig8Request {
10026 type Constraint = ();
10027
10028 fn validate(
10029 _: ::fidl_next::Slot<'_, Self>,
10030 _: Self::Constraint,
10031 ) -> Result<(), ::fidl_next::ValidationError> {
10032 Ok(())
10033 }
10034 }
10035
10036 unsafe impl ::fidl_next::Wire for DeviceWriteConfig8Request {
10037 type Narrowed<'de> = DeviceWriteConfig8Request;
10038
10039 #[inline]
10040 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10041 ::fidl_next::munge! {
10042 let Self {
10043 offset,
10044 value,
10045
10046 } = &mut *out_;
10047 }
10048
10049 ::fidl_next::Wire::zero_padding(offset);
10050
10051 ::fidl_next::Wire::zero_padding(value);
10052
10053 unsafe {
10054 out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 1);
10055 }
10056 }
10057 }
10058
10059 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig8Request
10060 where
10061 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10062 {
10063 fn decode(
10064 slot_: ::fidl_next::Slot<'_, Self>,
10065 decoder_: &mut ___D,
10066 _: (),
10067 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10068 if slot_.as_bytes()[3..4] != [0u8; 1] {
10069 return Err(::fidl_next::DecodeError::InvalidPadding);
10070 }
10071
10072 ::fidl_next::munge! {
10073 let Self {
10074 mut offset,
10075 mut value,
10076
10077 } = slot_;
10078 }
10079
10080 let _field = offset.as_mut();
10081
10082 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
10083
10084 let _field = value.as_mut();
10085
10086 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10087
10088 Ok(())
10089 }
10090 }
10091
10092 impl ::fidl_next::IntoNatural for DeviceWriteConfig8Request {
10093 type Natural = crate::natural::DeviceWriteConfig8Request;
10094 }
10095
10096 pub type DeviceWriteConfig8Response = ::fidl_next::wire::Unit;
10098
10099 #[derive(Clone, Debug)]
10101 #[repr(C)]
10102 pub struct DeviceWriteConfig16Request {
10103 pub offset: ::fidl_next::wire::Uint16,
10104
10105 pub value: ::fidl_next::wire::Uint16,
10106 }
10107
10108 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig16Request>(), 4);
10109 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig16Request>(), 2);
10110
10111 static_assertions::const_assert_eq!(
10112 std::mem::offset_of!(DeviceWriteConfig16Request, offset),
10113 0
10114 );
10115
10116 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig16Request, value), 2);
10117
10118 impl ::fidl_next::Constrained for DeviceWriteConfig16Request {
10119 type Constraint = ();
10120
10121 fn validate(
10122 _: ::fidl_next::Slot<'_, Self>,
10123 _: Self::Constraint,
10124 ) -> Result<(), ::fidl_next::ValidationError> {
10125 Ok(())
10126 }
10127 }
10128
10129 unsafe impl ::fidl_next::Wire for DeviceWriteConfig16Request {
10130 type Narrowed<'de> = DeviceWriteConfig16Request;
10131
10132 #[inline]
10133 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10134 ::fidl_next::munge! {
10135 let Self {
10136 offset,
10137 value,
10138
10139 } = &mut *out_;
10140 }
10141
10142 ::fidl_next::Wire::zero_padding(offset);
10143
10144 ::fidl_next::Wire::zero_padding(value);
10145 }
10146 }
10147
10148 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig16Request
10149 where
10150 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10151 {
10152 fn decode(
10153 slot_: ::fidl_next::Slot<'_, Self>,
10154 decoder_: &mut ___D,
10155 _: (),
10156 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10157 ::fidl_next::munge! {
10158 let Self {
10159 mut offset,
10160 mut value,
10161
10162 } = slot_;
10163 }
10164
10165 let _field = offset.as_mut();
10166
10167 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
10168
10169 let _field = value.as_mut();
10170
10171 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10172
10173 Ok(())
10174 }
10175 }
10176
10177 impl ::fidl_next::IntoNatural for DeviceWriteConfig16Request {
10178 type Natural = crate::natural::DeviceWriteConfig16Request;
10179 }
10180
10181 pub type DeviceWriteConfig16Response = ::fidl_next::wire::Unit;
10183
10184 #[derive(Clone, Debug)]
10186 #[repr(C)]
10187 pub struct DeviceWriteConfig32Request {
10188 pub offset: ::fidl_next::wire::Uint16,
10189
10190 pub value: ::fidl_next::wire::Uint32,
10191 }
10192
10193 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceWriteConfig32Request>(), 8);
10194 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceWriteConfig32Request>(), 4);
10195
10196 static_assertions::const_assert_eq!(
10197 std::mem::offset_of!(DeviceWriteConfig32Request, offset),
10198 0
10199 );
10200
10201 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceWriteConfig32Request, value), 4);
10202
10203 impl ::fidl_next::Constrained for DeviceWriteConfig32Request {
10204 type Constraint = ();
10205
10206 fn validate(
10207 _: ::fidl_next::Slot<'_, Self>,
10208 _: Self::Constraint,
10209 ) -> Result<(), ::fidl_next::ValidationError> {
10210 Ok(())
10211 }
10212 }
10213
10214 unsafe impl ::fidl_next::Wire for DeviceWriteConfig32Request {
10215 type Narrowed<'de> = DeviceWriteConfig32Request;
10216
10217 #[inline]
10218 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10219 ::fidl_next::munge! {
10220 let Self {
10221 offset,
10222 value,
10223
10224 } = &mut *out_;
10225 }
10226
10227 ::fidl_next::Wire::zero_padding(offset);
10228
10229 ::fidl_next::Wire::zero_padding(value);
10230
10231 unsafe {
10232 out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 2);
10233 }
10234 }
10235 }
10236
10237 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWriteConfig32Request
10238 where
10239 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10240 {
10241 fn decode(
10242 slot_: ::fidl_next::Slot<'_, Self>,
10243 decoder_: &mut ___D,
10244 _: (),
10245 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10246 if slot_.as_bytes()[2..4] != [0u8; 2] {
10247 return Err(::fidl_next::DecodeError::InvalidPadding);
10248 }
10249
10250 ::fidl_next::munge! {
10251 let Self {
10252 mut offset,
10253 mut value,
10254
10255 } = slot_;
10256 }
10257
10258 let _field = offset.as_mut();
10259
10260 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
10261
10262 let _field = value.as_mut();
10263
10264 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10265
10266 Ok(())
10267 }
10268 }
10269
10270 impl ::fidl_next::IntoNatural for DeviceWriteConfig32Request {
10271 type Natural = crate::natural::DeviceWriteConfig32Request;
10272 }
10273
10274 pub type DeviceWriteConfig32Response = ::fidl_next::wire::Unit;
10276
10277 #[derive(Clone, Debug)]
10279 #[repr(C)]
10280 pub struct DeviceGetCapabilitiesRequest {
10281 pub id: crate::wire::CapabilityId,
10282 }
10283
10284 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetCapabilitiesRequest>(), 1);
10285 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetCapabilitiesRequest>(), 1);
10286
10287 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetCapabilitiesRequest, id), 0);
10288
10289 impl ::fidl_next::Constrained for DeviceGetCapabilitiesRequest {
10290 type Constraint = ();
10291
10292 fn validate(
10293 _: ::fidl_next::Slot<'_, Self>,
10294 _: Self::Constraint,
10295 ) -> Result<(), ::fidl_next::ValidationError> {
10296 Ok(())
10297 }
10298 }
10299
10300 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesRequest {
10301 type Narrowed<'de> = DeviceGetCapabilitiesRequest;
10302
10303 #[inline]
10304 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10305 ::fidl_next::munge! {
10306 let Self {
10307 id,
10308
10309 } = &mut *out_;
10310 }
10311
10312 ::fidl_next::Wire::zero_padding(id);
10313 }
10314 }
10315
10316 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesRequest
10317 where
10318 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10319 {
10320 fn decode(
10321 slot_: ::fidl_next::Slot<'_, Self>,
10322 decoder_: &mut ___D,
10323 _: (),
10324 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10325 ::fidl_next::munge! {
10326 let Self {
10327 mut id,
10328
10329 } = slot_;
10330 }
10331
10332 let _field = id.as_mut();
10333
10334 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10335
10336 Ok(())
10337 }
10338 }
10339
10340 impl ::fidl_next::IntoNatural for DeviceGetCapabilitiesRequest {
10341 type Natural = crate::natural::DeviceGetCapabilitiesRequest;
10342 }
10343
10344 #[derive(Debug)]
10346 #[repr(C)]
10347 pub struct DeviceGetCapabilitiesResponse<'de> {
10348 pub offsets: ::fidl_next::wire::Vector<'de, u8>,
10349 }
10350
10351 static_assertions::const_assert_eq!(
10352 std::mem::size_of::<DeviceGetCapabilitiesResponse<'_>>(),
10353 16
10354 );
10355 static_assertions::const_assert_eq!(
10356 std::mem::align_of::<DeviceGetCapabilitiesResponse<'_>>(),
10357 8
10358 );
10359
10360 static_assertions::const_assert_eq!(
10361 std::mem::offset_of!(DeviceGetCapabilitiesResponse<'_>, offsets),
10362 0
10363 );
10364
10365 impl ::fidl_next::Constrained for DeviceGetCapabilitiesResponse<'_> {
10366 type Constraint = ();
10367
10368 fn validate(
10369 _: ::fidl_next::Slot<'_, Self>,
10370 _: Self::Constraint,
10371 ) -> Result<(), ::fidl_next::ValidationError> {
10372 Ok(())
10373 }
10374 }
10375
10376 unsafe impl ::fidl_next::Wire for DeviceGetCapabilitiesResponse<'static> {
10377 type Narrowed<'de> = DeviceGetCapabilitiesResponse<'de>;
10378
10379 #[inline]
10380 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10381 ::fidl_next::munge! {
10382 let Self {
10383 offsets,
10384
10385 } = &mut *out_;
10386 }
10387
10388 ::fidl_next::Wire::zero_padding(offsets);
10389 }
10390 }
10391
10392 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetCapabilitiesResponse<'de>
10393 where
10394 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10395 ___D: ::fidl_next::Decoder<'de>,
10396 {
10397 fn decode(
10398 slot_: ::fidl_next::Slot<'_, Self>,
10399 decoder_: &mut ___D,
10400 _: (),
10401 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10402 ::fidl_next::munge! {
10403 let Self {
10404 mut offsets,
10405
10406 } = slot_;
10407 }
10408
10409 let _field = offsets.as_mut();
10410 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10411 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
10412
10413 let offsets = unsafe { offsets.deref_unchecked() };
10414
10415 if offsets.len() > 32 {
10416 return Err(::fidl_next::DecodeError::VectorTooLong {
10417 size: offsets.len() as u64,
10418 limit: 32,
10419 });
10420 }
10421
10422 Ok(())
10423 }
10424 }
10425
10426 impl<'de> ::fidl_next::IntoNatural for DeviceGetCapabilitiesResponse<'de> {
10427 type Natural = crate::natural::DeviceGetCapabilitiesResponse;
10428 }
10429
10430 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10432 #[repr(transparent)]
10433 pub struct ExtendedCapabilityId {
10434 pub(crate) value: ::fidl_next::wire::Uint16,
10435 }
10436
10437 impl ::fidl_next::Constrained for ExtendedCapabilityId {
10438 type Constraint = ();
10439
10440 fn validate(
10441 _: ::fidl_next::Slot<'_, Self>,
10442 _: Self::Constraint,
10443 ) -> Result<(), ::fidl_next::ValidationError> {
10444 Ok(())
10445 }
10446 }
10447
10448 unsafe impl ::fidl_next::Wire for ExtendedCapabilityId {
10449 type Narrowed<'de> = Self;
10450
10451 #[inline]
10452 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10453 }
10455 }
10456
10457 impl ExtendedCapabilityId {
10458 pub const NULL: ExtendedCapabilityId =
10459 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(0) };
10460
10461 pub const ADVANCED_ERROR_REPORTING: ExtendedCapabilityId =
10462 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(1) };
10463
10464 pub const VIRTUAL_CHANNEL_NO_MFVC: ExtendedCapabilityId =
10465 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(2) };
10466
10467 pub const DEVICE_SERIAL_NUMBER: ExtendedCapabilityId =
10468 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(3) };
10469
10470 pub const POWER_BUDGETING: ExtendedCapabilityId =
10471 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(4) };
10472
10473 pub const ROOT_COMPLEX_LINK_DECLARATION: ExtendedCapabilityId =
10474 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(5) };
10475
10476 pub const ROOT_COMPLEX_INTERNAL_LINK_CONTROL: ExtendedCapabilityId =
10477 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(6) };
10478
10479 pub const ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION: ExtendedCapabilityId =
10480 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(7) };
10481
10482 pub const MULTI_FUNCTION_VIRTUAL_CHANNEL: ExtendedCapabilityId =
10483 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(8) };
10484
10485 pub const VIRTUAL_CHANNEL: ExtendedCapabilityId =
10486 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(9) };
10487
10488 pub const RCRB: ExtendedCapabilityId =
10489 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(10) };
10490
10491 pub const VENDOR: ExtendedCapabilityId =
10492 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(11) };
10493
10494 pub const CAC: ExtendedCapabilityId =
10495 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(12) };
10496
10497 pub const ACS: ExtendedCapabilityId =
10498 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(13) };
10499
10500 pub const ARI: ExtendedCapabilityId =
10501 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(14) };
10502
10503 pub const ATS: ExtendedCapabilityId =
10504 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(15) };
10505
10506 pub const SR_IOV: ExtendedCapabilityId =
10507 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(16) };
10508
10509 pub const MR_IOV: ExtendedCapabilityId =
10510 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(17) };
10511
10512 pub const MULTICAST: ExtendedCapabilityId =
10513 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(18) };
10514
10515 pub const PRI: ExtendedCapabilityId =
10516 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(19) };
10517
10518 pub const ENHANCED_ALLOCATION: ExtendedCapabilityId =
10519 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(20) };
10520
10521 pub const RESIZABLE_BAR: ExtendedCapabilityId =
10522 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(21) };
10523
10524 pub const DYNAMIC_POWER_ALLOCATION: ExtendedCapabilityId =
10525 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(22) };
10526
10527 pub const TPH: ExtendedCapabilityId =
10528 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(23) };
10529
10530 pub const LATENCY_TOLERANCE_REPORTING: ExtendedCapabilityId =
10531 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(24) };
10532
10533 pub const SECONDARY_PCI_EXPRESS: ExtendedCapabilityId =
10534 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(25) };
10535
10536 pub const PMUX: ExtendedCapabilityId =
10537 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(26) };
10538
10539 pub const PASID: ExtendedCapabilityId =
10540 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(27) };
10541
10542 pub const LNR: ExtendedCapabilityId =
10543 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(28) };
10544
10545 pub const DPC: ExtendedCapabilityId =
10546 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(29) };
10547
10548 pub const L1_PM_SUBSTATES: ExtendedCapabilityId =
10549 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(30) };
10550
10551 pub const PRECISION_TIME_MEASUREMENT: ExtendedCapabilityId =
10552 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(31) };
10553
10554 pub const MPCIE: ExtendedCapabilityId =
10555 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(32) };
10556
10557 pub const FRS_QUEUEING: ExtendedCapabilityId =
10558 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(33) };
10559
10560 pub const READINESS_TIME_REPORTING: ExtendedCapabilityId =
10561 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(34) };
10562
10563 pub const DESIGNATED_VENDOR: ExtendedCapabilityId =
10564 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(35) };
10565
10566 pub const VF_RESIZABLE_BAR: ExtendedCapabilityId =
10567 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(36) };
10568
10569 pub const DATA_LINK_FEATURE: ExtendedCapabilityId =
10570 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(37) };
10571
10572 pub const PHYSICAL_LAYER_16: ExtendedCapabilityId =
10573 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(38) };
10574
10575 pub const LANE_MARGINING_AT_RECEIVER: ExtendedCapabilityId =
10576 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(39) };
10577
10578 pub const HIERARCHY_ID: ExtendedCapabilityId =
10579 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(40) };
10580
10581 pub const NATIVE_PCIE_ENCLOSURE: ExtendedCapabilityId =
10582 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(41) };
10583
10584 pub const PHYSICAL_LAYER_32: ExtendedCapabilityId =
10585 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(42) };
10586
10587 pub const ALTERNATE_PROTOCOL: ExtendedCapabilityId =
10588 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(43) };
10589
10590 pub const SYSTEM_FIRMWARE_INTERMEDIARY: ExtendedCapabilityId =
10591 ExtendedCapabilityId { value: ::fidl_next::wire::Uint16(44) };
10592 }
10593
10594 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedCapabilityId
10595 where
10596 ___D: ?Sized,
10597 {
10598 fn decode(
10599 slot: ::fidl_next::Slot<'_, Self>,
10600 _: &mut ___D,
10601 _: (),
10602 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10603 Ok(())
10604 }
10605 }
10606
10607 impl ::core::convert::From<crate::natural::ExtendedCapabilityId> for ExtendedCapabilityId {
10608 fn from(natural: crate::natural::ExtendedCapabilityId) -> Self {
10609 match natural {
10610
10611 crate::natural::ExtendedCapabilityId::Null => ExtendedCapabilityId::NULL,
10612
10613 crate::natural::ExtendedCapabilityId::AdvancedErrorReporting => ExtendedCapabilityId::ADVANCED_ERROR_REPORTING,
10614
10615 crate::natural::ExtendedCapabilityId::VirtualChannelNoMfvc => ExtendedCapabilityId::VIRTUAL_CHANNEL_NO_MFVC,
10616
10617 crate::natural::ExtendedCapabilityId::DeviceSerialNumber => ExtendedCapabilityId::DEVICE_SERIAL_NUMBER,
10618
10619 crate::natural::ExtendedCapabilityId::PowerBudgeting => ExtendedCapabilityId::POWER_BUDGETING,
10620
10621 crate::natural::ExtendedCapabilityId::RootComplexLinkDeclaration => ExtendedCapabilityId::ROOT_COMPLEX_LINK_DECLARATION,
10622
10623 crate::natural::ExtendedCapabilityId::RootComplexInternalLinkControl => ExtendedCapabilityId::ROOT_COMPLEX_INTERNAL_LINK_CONTROL,
10624
10625 crate::natural::ExtendedCapabilityId::RootComplexEventCollectorEndpointAssociation => ExtendedCapabilityId::ROOT_COMPLEX_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION,
10626
10627 crate::natural::ExtendedCapabilityId::MultiFunctionVirtualChannel => ExtendedCapabilityId::MULTI_FUNCTION_VIRTUAL_CHANNEL,
10628
10629 crate::natural::ExtendedCapabilityId::VirtualChannel => ExtendedCapabilityId::VIRTUAL_CHANNEL,
10630
10631 crate::natural::ExtendedCapabilityId::Rcrb => ExtendedCapabilityId::RCRB,
10632
10633 crate::natural::ExtendedCapabilityId::Vendor => ExtendedCapabilityId::VENDOR,
10634
10635 crate::natural::ExtendedCapabilityId::Cac => ExtendedCapabilityId::CAC,
10636
10637 crate::natural::ExtendedCapabilityId::Acs => ExtendedCapabilityId::ACS,
10638
10639 crate::natural::ExtendedCapabilityId::Ari => ExtendedCapabilityId::ARI,
10640
10641 crate::natural::ExtendedCapabilityId::Ats => ExtendedCapabilityId::ATS,
10642
10643 crate::natural::ExtendedCapabilityId::SrIov => ExtendedCapabilityId::SR_IOV,
10644
10645 crate::natural::ExtendedCapabilityId::MrIov => ExtendedCapabilityId::MR_IOV,
10646
10647 crate::natural::ExtendedCapabilityId::Multicast => ExtendedCapabilityId::MULTICAST,
10648
10649 crate::natural::ExtendedCapabilityId::Pri => ExtendedCapabilityId::PRI,
10650
10651 crate::natural::ExtendedCapabilityId::EnhancedAllocation => ExtendedCapabilityId::ENHANCED_ALLOCATION,
10652
10653 crate::natural::ExtendedCapabilityId::ResizableBar => ExtendedCapabilityId::RESIZABLE_BAR,
10654
10655 crate::natural::ExtendedCapabilityId::DynamicPowerAllocation => ExtendedCapabilityId::DYNAMIC_POWER_ALLOCATION,
10656
10657 crate::natural::ExtendedCapabilityId::Tph => ExtendedCapabilityId::TPH,
10658
10659 crate::natural::ExtendedCapabilityId::LatencyToleranceReporting => ExtendedCapabilityId::LATENCY_TOLERANCE_REPORTING,
10660
10661 crate::natural::ExtendedCapabilityId::SecondaryPciExpress => ExtendedCapabilityId::SECONDARY_PCI_EXPRESS,
10662
10663 crate::natural::ExtendedCapabilityId::Pmux => ExtendedCapabilityId::PMUX,
10664
10665 crate::natural::ExtendedCapabilityId::Pasid => ExtendedCapabilityId::PASID,
10666
10667 crate::natural::ExtendedCapabilityId::Lnr => ExtendedCapabilityId::LNR,
10668
10669 crate::natural::ExtendedCapabilityId::Dpc => ExtendedCapabilityId::DPC,
10670
10671 crate::natural::ExtendedCapabilityId::L1PmSubstates => ExtendedCapabilityId::L1_PM_SUBSTATES,
10672
10673 crate::natural::ExtendedCapabilityId::PrecisionTimeMeasurement => ExtendedCapabilityId::PRECISION_TIME_MEASUREMENT,
10674
10675 crate::natural::ExtendedCapabilityId::Mpcie => ExtendedCapabilityId::MPCIE,
10676
10677 crate::natural::ExtendedCapabilityId::FrsQueueing => ExtendedCapabilityId::FRS_QUEUEING,
10678
10679 crate::natural::ExtendedCapabilityId::ReadinessTimeReporting => ExtendedCapabilityId::READINESS_TIME_REPORTING,
10680
10681 crate::natural::ExtendedCapabilityId::DesignatedVendor => ExtendedCapabilityId::DESIGNATED_VENDOR,
10682
10683 crate::natural::ExtendedCapabilityId::VfResizableBar => ExtendedCapabilityId::VF_RESIZABLE_BAR,
10684
10685 crate::natural::ExtendedCapabilityId::DataLinkFeature => ExtendedCapabilityId::DATA_LINK_FEATURE,
10686
10687 crate::natural::ExtendedCapabilityId::PhysicalLayer16 => ExtendedCapabilityId::PHYSICAL_LAYER_16,
10688
10689 crate::natural::ExtendedCapabilityId::LaneMarginingAtReceiver => ExtendedCapabilityId::LANE_MARGINING_AT_RECEIVER,
10690
10691 crate::natural::ExtendedCapabilityId::HierarchyId => ExtendedCapabilityId::HIERARCHY_ID,
10692
10693 crate::natural::ExtendedCapabilityId::NativePcieEnclosure => ExtendedCapabilityId::NATIVE_PCIE_ENCLOSURE,
10694
10695 crate::natural::ExtendedCapabilityId::PhysicalLayer32 => ExtendedCapabilityId::PHYSICAL_LAYER_32,
10696
10697 crate::natural::ExtendedCapabilityId::AlternateProtocol => ExtendedCapabilityId::ALTERNATE_PROTOCOL,
10698
10699 crate::natural::ExtendedCapabilityId::SystemFirmwareIntermediary => ExtendedCapabilityId::SYSTEM_FIRMWARE_INTERMEDIARY,
10700
10701
10702 crate::natural::ExtendedCapabilityId::UnknownOrdinal_(value) => ExtendedCapabilityId {
10703 value: ::fidl_next::wire::Uint16::from(value),
10704 }
10705
10706 }
10707 }
10708 }
10709
10710 impl ::fidl_next::IntoNatural for ExtendedCapabilityId {
10711 type Natural = crate::natural::ExtendedCapabilityId;
10712 }
10713
10714 #[derive(Clone, Debug)]
10716 #[repr(C)]
10717 pub struct DeviceGetExtendedCapabilitiesRequest {
10718 pub id: crate::wire::ExtendedCapabilityId,
10719 }
10720
10721 static_assertions::const_assert_eq!(
10722 std::mem::size_of::<DeviceGetExtendedCapabilitiesRequest>(),
10723 2
10724 );
10725 static_assertions::const_assert_eq!(
10726 std::mem::align_of::<DeviceGetExtendedCapabilitiesRequest>(),
10727 2
10728 );
10729
10730 static_assertions::const_assert_eq!(
10731 std::mem::offset_of!(DeviceGetExtendedCapabilitiesRequest, id),
10732 0
10733 );
10734
10735 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesRequest {
10736 type Constraint = ();
10737
10738 fn validate(
10739 _: ::fidl_next::Slot<'_, Self>,
10740 _: Self::Constraint,
10741 ) -> Result<(), ::fidl_next::ValidationError> {
10742 Ok(())
10743 }
10744 }
10745
10746 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesRequest {
10747 type Narrowed<'de> = DeviceGetExtendedCapabilitiesRequest;
10748
10749 #[inline]
10750 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10751 ::fidl_next::munge! {
10752 let Self {
10753 id,
10754
10755 } = &mut *out_;
10756 }
10757
10758 ::fidl_next::Wire::zero_padding(id);
10759 }
10760 }
10761
10762 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesRequest
10763 where
10764 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10765 {
10766 fn decode(
10767 slot_: ::fidl_next::Slot<'_, Self>,
10768 decoder_: &mut ___D,
10769 _: (),
10770 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10771 ::fidl_next::munge! {
10772 let Self {
10773 mut id,
10774
10775 } = slot_;
10776 }
10777
10778 let _field = id.as_mut();
10779
10780 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10781
10782 Ok(())
10783 }
10784 }
10785
10786 impl ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesRequest {
10787 type Natural = crate::natural::DeviceGetExtendedCapabilitiesRequest;
10788 }
10789
10790 #[derive(Debug)]
10792 #[repr(C)]
10793 pub struct DeviceGetExtendedCapabilitiesResponse<'de> {
10794 pub offsets: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
10795 }
10796
10797 static_assertions::const_assert_eq!(
10798 std::mem::size_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10799 16
10800 );
10801 static_assertions::const_assert_eq!(
10802 std::mem::align_of::<DeviceGetExtendedCapabilitiesResponse<'_>>(),
10803 8
10804 );
10805
10806 static_assertions::const_assert_eq!(
10807 std::mem::offset_of!(DeviceGetExtendedCapabilitiesResponse<'_>, offsets),
10808 0
10809 );
10810
10811 impl ::fidl_next::Constrained for DeviceGetExtendedCapabilitiesResponse<'_> {
10812 type Constraint = ();
10813
10814 fn validate(
10815 _: ::fidl_next::Slot<'_, Self>,
10816 _: Self::Constraint,
10817 ) -> Result<(), ::fidl_next::ValidationError> {
10818 Ok(())
10819 }
10820 }
10821
10822 unsafe impl ::fidl_next::Wire for DeviceGetExtendedCapabilitiesResponse<'static> {
10823 type Narrowed<'de> = DeviceGetExtendedCapabilitiesResponse<'de>;
10824
10825 #[inline]
10826 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10827 ::fidl_next::munge! {
10828 let Self {
10829 offsets,
10830
10831 } = &mut *out_;
10832 }
10833
10834 ::fidl_next::Wire::zero_padding(offsets);
10835 }
10836 }
10837
10838 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceGetExtendedCapabilitiesResponse<'de>
10839 where
10840 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10841 ___D: ::fidl_next::Decoder<'de>,
10842 {
10843 fn decode(
10844 slot_: ::fidl_next::Slot<'_, Self>,
10845 decoder_: &mut ___D,
10846 _: (),
10847 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10848 ::fidl_next::munge! {
10849 let Self {
10850 mut offsets,
10851
10852 } = slot_;
10853 }
10854
10855 let _field = offsets.as_mut();
10856 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10857 ::fidl_next::Decode::decode(offsets.as_mut(), decoder_, (32, ()))?;
10858
10859 let offsets = unsafe { offsets.deref_unchecked() };
10860
10861 if offsets.len() > 32 {
10862 return Err(::fidl_next::DecodeError::VectorTooLong {
10863 size: offsets.len() as u64,
10864 limit: 32,
10865 });
10866 }
10867
10868 Ok(())
10869 }
10870 }
10871
10872 impl<'de> ::fidl_next::IntoNatural for DeviceGetExtendedCapabilitiesResponse<'de> {
10873 type Natural = crate::natural::DeviceGetExtendedCapabilitiesResponse;
10874 }
10875
10876 #[derive(Clone, Debug)]
10878 #[repr(C)]
10879 pub struct DeviceGetBtiRequest {
10880 pub index: ::fidl_next::wire::Uint32,
10881 }
10882
10883 static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetBtiRequest>(), 4);
10884 static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetBtiRequest>(), 4);
10885
10886 static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetBtiRequest, index), 0);
10887
10888 impl ::fidl_next::Constrained for DeviceGetBtiRequest {
10889 type Constraint = ();
10890
10891 fn validate(
10892 _: ::fidl_next::Slot<'_, Self>,
10893 _: Self::Constraint,
10894 ) -> Result<(), ::fidl_next::ValidationError> {
10895 Ok(())
10896 }
10897 }
10898
10899 unsafe impl ::fidl_next::Wire for DeviceGetBtiRequest {
10900 type Narrowed<'de> = DeviceGetBtiRequest;
10901
10902 #[inline]
10903 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10904 ::fidl_next::munge! {
10905 let Self {
10906 index,
10907
10908 } = &mut *out_;
10909 }
10910
10911 ::fidl_next::Wire::zero_padding(index);
10912 }
10913 }
10914
10915 unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetBtiRequest
10916 where
10917 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10918 {
10919 fn decode(
10920 slot_: ::fidl_next::Slot<'_, Self>,
10921 decoder_: &mut ___D,
10922 _: (),
10923 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10924 ::fidl_next::munge! {
10925 let Self {
10926 mut index,
10927
10928 } = slot_;
10929 }
10930
10931 let _field = index.as_mut();
10932
10933 ::fidl_next::Decode::decode(index.as_mut(), decoder_, ())?;
10934
10935 Ok(())
10936 }
10937 }
10938
10939 impl ::fidl_next::IntoNatural for DeviceGetBtiRequest {
10940 type Natural = crate::natural::DeviceGetBtiRequest;
10941 }
10942
10943 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10945 #[repr(transparent)]
10946 pub struct HeaderType {
10947 pub(crate) value: u8,
10948 }
10949
10950 impl ::fidl_next::Constrained for HeaderType {
10951 type Constraint = ();
10952
10953 fn validate(
10954 _: ::fidl_next::Slot<'_, Self>,
10955 _: Self::Constraint,
10956 ) -> Result<(), ::fidl_next::ValidationError> {
10957 Ok(())
10958 }
10959 }
10960
10961 unsafe impl ::fidl_next::Wire for HeaderType {
10962 type Narrowed<'de> = Self;
10963
10964 #[inline]
10965 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10966 }
10968 }
10969
10970 impl HeaderType {
10971 pub const STANDARD: HeaderType = HeaderType { value: 0 };
10972
10973 pub const BRIDGE: HeaderType = HeaderType { value: 1 };
10974
10975 pub const CARD_BUS: HeaderType = HeaderType { value: 2 };
10976
10977 pub const MASK: HeaderType = HeaderType { value: 127 };
10978
10979 pub const MULTI_FN: HeaderType = HeaderType { value: 128 };
10980 }
10981
10982 unsafe impl<___D> ::fidl_next::Decode<___D> for HeaderType
10983 where
10984 ___D: ?Sized,
10985 {
10986 fn decode(
10987 slot: ::fidl_next::Slot<'_, Self>,
10988 _: &mut ___D,
10989 _: (),
10990 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10991 Ok(())
10992 }
10993 }
10994
10995 impl ::core::convert::From<crate::natural::HeaderType> for HeaderType {
10996 fn from(natural: crate::natural::HeaderType) -> Self {
10997 match natural {
10998 crate::natural::HeaderType::Standard => HeaderType::STANDARD,
10999
11000 crate::natural::HeaderType::Bridge => HeaderType::BRIDGE,
11001
11002 crate::natural::HeaderType::CardBus => HeaderType::CARD_BUS,
11003
11004 crate::natural::HeaderType::Mask => HeaderType::MASK,
11005
11006 crate::natural::HeaderType::MultiFn => HeaderType::MULTI_FN,
11007
11008 crate::natural::HeaderType::UnknownOrdinal_(value) => {
11009 HeaderType { value: u8::from(value) }
11010 }
11011 }
11012 }
11013 }
11014
11015 impl ::fidl_next::IntoNatural for HeaderType {
11016 type Natural = crate::natural::HeaderType;
11017 }
11018
11019 #[derive(Clone, Copy, Debug)]
11021 #[repr(transparent)]
11022 pub struct Status {
11023 pub(crate) value: ::fidl_next::wire::Uint16,
11024 }
11025
11026 impl ::fidl_next::Constrained for Status {
11027 type Constraint = ();
11028
11029 fn validate(
11030 _: ::fidl_next::Slot<'_, Self>,
11031 _: Self::Constraint,
11032 ) -> Result<(), ::fidl_next::ValidationError> {
11033 Ok(())
11034 }
11035 }
11036
11037 unsafe impl ::fidl_next::Wire for Status {
11038 type Narrowed<'de> = Self;
11039
11040 #[inline]
11041 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11042 }
11044 }
11045
11046 unsafe impl<___D> ::fidl_next::Decode<___D> for Status
11047 where
11048 ___D: ?Sized,
11049 {
11050 fn decode(
11051 slot: ::fidl_next::Slot<'_, Self>,
11052 _: &mut ___D,
11053 _: (),
11054 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11055 Ok(())
11056 }
11057 }
11058
11059 impl ::core::convert::From<crate::natural::Status> for Status {
11060 fn from(natural: crate::natural::Status) -> Self {
11061 Self { value: ::fidl_next::wire::Uint16::from(natural.bits()) }
11062 }
11063 }
11064
11065 impl ::fidl_next::IntoNatural for Status {
11066 type Natural = crate::natural::Status;
11067 }
11068}
11069
11070pub mod wire_optional {}
11071
11072pub mod generic {
11073
11074 pub struct Address<T0, T1, T2> {
11076 pub bus: T0,
11077
11078 pub device: T1,
11079
11080 pub function: T2,
11081 }
11082
11083 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Address, ___E>
11084 for Address<T0, T1, T2>
11085 where
11086 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11087 T0: ::fidl_next::Encode<u8, ___E>,
11088 T1: ::fidl_next::Encode<u8, ___E>,
11089 T2: ::fidl_next::Encode<u8, ___E>,
11090 {
11091 #[inline]
11092 fn encode(
11093 self,
11094 encoder_: &mut ___E,
11095 out_: &mut ::core::mem::MaybeUninit<crate::wire::Address>,
11096 _: (),
11097 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11098 ::fidl_next::munge! {
11099 let crate::wire::Address {
11100 bus,
11101 device,
11102 function,
11103
11104 } = out_;
11105 }
11106
11107 ::fidl_next::Encode::encode(self.bus, encoder_, bus, ())?;
11108
11109 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
11110
11111 ::fidl_next::Encode::encode(self.function, encoder_, function, ())?;
11112
11113 Ok(())
11114 }
11115 }
11116
11117 pub struct BaseAddress<T0, T1, T2, T3, T4, T5> {
11119 pub address: T0,
11120
11121 pub size: T1,
11122
11123 pub is_memory: T2,
11124
11125 pub is_prefetchable: T3,
11126
11127 pub is_64bit: T4,
11128
11129 pub id: T5,
11130 }
11131
11132 unsafe impl<___E, T0, T1, T2, T3, T4, T5> ::fidl_next::Encode<crate::wire::BaseAddress, ___E>
11133 for BaseAddress<T0, T1, T2, T3, T4, T5>
11134 where
11135 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11136 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11137 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11138 T2: ::fidl_next::Encode<bool, ___E>,
11139 T3: ::fidl_next::Encode<bool, ___E>,
11140 T4: ::fidl_next::Encode<bool, ___E>,
11141 T5: ::fidl_next::Encode<u8, ___E>,
11142 {
11143 #[inline]
11144 fn encode(
11145 self,
11146 encoder_: &mut ___E,
11147 out_: &mut ::core::mem::MaybeUninit<crate::wire::BaseAddress>,
11148 _: (),
11149 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11150 ::fidl_next::munge! {
11151 let crate::wire::BaseAddress {
11152 address,
11153 size,
11154 is_memory,
11155 is_prefetchable,
11156 is_64bit,
11157 id,
11158
11159 } = out_;
11160 }
11161
11162 ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;
11163
11164 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
11165
11166 ::fidl_next::Encode::encode(self.is_memory, encoder_, is_memory, ())?;
11167
11168 ::fidl_next::Encode::encode(self.is_prefetchable, encoder_, is_prefetchable, ())?;
11169
11170 ::fidl_next::Encode::encode(self.is_64bit, encoder_, is_64bit, ())?;
11171
11172 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11173
11174 Ok(())
11175 }
11176 }
11177
11178 pub struct Bdf<T0, T1, T2> {
11180 pub bus_id: T0,
11181
11182 pub device_id: T1,
11183
11184 pub function_id: T2,
11185 }
11186
11187 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Bdf, ___E> for Bdf<T0, T1, T2>
11188 where
11189 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11190 T0: ::fidl_next::Encode<u8, ___E>,
11191 T1: ::fidl_next::Encode<u8, ___E>,
11192 T2: ::fidl_next::Encode<u8, ___E>,
11193 {
11194 #[inline]
11195 fn encode(
11196 self,
11197 encoder_: &mut ___E,
11198 out_: &mut ::core::mem::MaybeUninit<crate::wire::Bdf>,
11199 _: (),
11200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11201 ::fidl_next::munge! {
11202 let crate::wire::Bdf {
11203 bus_id,
11204 device_id,
11205 function_id,
11206
11207 } = out_;
11208 }
11209
11210 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11211
11212 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11213
11214 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
11215
11216 Ok(())
11217 }
11218 }
11219
11220 pub type UseIntxWorkaroundType = ();
11222
11223 pub struct Capability<T0, T1> {
11225 pub id: T0,
11226
11227 pub offset: T1,
11228 }
11229
11230 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Capability, ___E> for Capability<T0, T1>
11231 where
11232 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11233 T0: ::fidl_next::Encode<u8, ___E>,
11234 T1: ::fidl_next::Encode<u8, ___E>,
11235 {
11236 #[inline]
11237 fn encode(
11238 self,
11239 encoder_: &mut ___E,
11240 out_: &mut ::core::mem::MaybeUninit<crate::wire::Capability>,
11241 _: (),
11242 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11243 ::fidl_next::munge! {
11244 let crate::wire::Capability {
11245 id,
11246 offset,
11247
11248 } = out_;
11249 }
11250
11251 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11252
11253 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11254
11255 Ok(())
11256 }
11257 }
11258
11259 pub struct HostBridgeInfo<T0, T1, T2, T3> {
11261 pub name: T0,
11262
11263 pub start_bus_number: T1,
11264
11265 pub end_bus_number: T2,
11266
11267 pub segment_group: T3,
11268 }
11269
11270 unsafe impl<___E, T0, T1, T2, T3>
11271 ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>
11272 for HostBridgeInfo<T0, T1, T2, T3>
11273 where
11274 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11275 ___E: ::fidl_next::Encoder,
11276 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
11277 T1: ::fidl_next::Encode<u8, ___E>,
11278 T2: ::fidl_next::Encode<u8, ___E>,
11279 T3: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11280 {
11281 #[inline]
11282 fn encode(
11283 self,
11284 encoder_: &mut ___E,
11285 out_: &mut ::core::mem::MaybeUninit<crate::wire::HostBridgeInfo<'static>>,
11286 _: (),
11287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11288 ::fidl_next::munge! {
11289 let crate::wire::HostBridgeInfo {
11290 name,
11291 start_bus_number,
11292 end_bus_number,
11293 segment_group,
11294
11295 } = out_;
11296 }
11297
11298 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
11299
11300 ::fidl_next::Encode::encode(self.start_bus_number, encoder_, start_bus_number, ())?;
11301
11302 ::fidl_next::Encode::encode(self.end_bus_number, encoder_, end_bus_number, ())?;
11303
11304 ::fidl_next::Encode::encode(self.segment_group, encoder_, segment_group, ())?;
11305
11306 Ok(())
11307 }
11308 }
11309
11310 pub struct DebugGetHostBridgeInfoResponse<T0> {
11312 pub info: T0,
11313 }
11314
11315 unsafe impl<___E, T0>
11316 ::fidl_next::Encode<crate::wire::DebugGetHostBridgeInfoResponse<'static>, ___E>
11317 for DebugGetHostBridgeInfoResponse<T0>
11318 where
11319 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11320 ___E: ::fidl_next::Encoder,
11321 T0: ::fidl_next::Encode<crate::wire::HostBridgeInfo<'static>, ___E>,
11322 {
11323 #[inline]
11324 fn encode(
11325 self,
11326 encoder_: &mut ___E,
11327 out_: &mut ::core::mem::MaybeUninit<
11328 crate::wire::DebugGetHostBridgeInfoResponse<'static>,
11329 >,
11330 _: (),
11331 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11332 ::fidl_next::munge! {
11333 let crate::wire::DebugGetHostBridgeInfoResponse {
11334 info,
11335
11336 } = out_;
11337 }
11338
11339 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
11340
11341 Ok(())
11342 }
11343 }
11344
11345 pub struct ExtendedCapability<T0, T1> {
11347 pub id: T0,
11348
11349 pub offset: T1,
11350 }
11351
11352 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ExtendedCapability, ___E>
11353 for ExtendedCapability<T0, T1>
11354 where
11355 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11356 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11357 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11358 {
11359 #[inline]
11360 fn encode(
11361 self,
11362 encoder_: &mut ___E,
11363 out_: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedCapability>,
11364 _: (),
11365 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11366 ::fidl_next::munge! {
11367 let crate::wire::ExtendedCapability {
11368 id,
11369 offset,
11370
11371 } = out_;
11372 }
11373
11374 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
11375
11376 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11377
11378 Ok(())
11379 }
11380 }
11381
11382 pub struct PciDevice<T0, T1, T2, T3, T4, T5, T6> {
11384 pub base_addresses: T0,
11385
11386 pub capabilities: T1,
11387
11388 pub ext_capabilities: T2,
11389
11390 pub config: T3,
11391
11392 pub bus_id: T4,
11393
11394 pub device_id: T5,
11395
11396 pub function_id: T6,
11397 }
11398
11399 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
11400 ::fidl_next::Encode<crate::wire::PciDevice<'static>, ___E>
11401 for PciDevice<T0, T1, T2, T3, T4, T5, T6>
11402 where
11403 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11404 ___E: ::fidl_next::Encoder,
11405 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::BaseAddress>, ___E>,
11406 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::Capability>, ___E>,
11407 T2: ::fidl_next::Encode<
11408 ::fidl_next::wire::Vector<'static, crate::wire::ExtendedCapability>,
11409 ___E,
11410 >,
11411 T3: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11412 T4: ::fidl_next::Encode<u8, ___E>,
11413 T5: ::fidl_next::Encode<u8, ___E>,
11414 T6: ::fidl_next::Encode<u8, ___E>,
11415 {
11416 #[inline]
11417 fn encode(
11418 self,
11419 encoder_: &mut ___E,
11420 out_: &mut ::core::mem::MaybeUninit<crate::wire::PciDevice<'static>>,
11421 _: (),
11422 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11423 ::fidl_next::munge! {
11424 let crate::wire::PciDevice {
11425 base_addresses,
11426 capabilities,
11427 ext_capabilities,
11428 config,
11429 bus_id,
11430 device_id,
11431 function_id,
11432
11433 } = out_;
11434 }
11435
11436 ::fidl_next::Encode::encode(self.base_addresses, encoder_, base_addresses, (6, ()))?;
11437
11438 ::fidl_next::Encode::encode(self.capabilities, encoder_, capabilities, (32, ()))?;
11439
11440 ::fidl_next::Encode::encode(
11441 self.ext_capabilities,
11442 encoder_,
11443 ext_capabilities,
11444 (32, ()),
11445 )?;
11446
11447 ::fidl_next::Encode::encode(self.config, encoder_, config, (256, ()))?;
11448
11449 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11450
11451 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11452
11453 ::fidl_next::Encode::encode(self.function_id, encoder_, function_id, ())?;
11454
11455 Ok(())
11456 }
11457 }
11458
11459 pub struct DebugGetDevicesResponse<T0> {
11461 pub devices: T0,
11462 }
11463
11464 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DebugGetDevicesResponse<'static>, ___E>
11465 for DebugGetDevicesResponse<T0>
11466 where
11467 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11468 ___E: ::fidl_next::Encoder,
11469 T0: ::fidl_next::Encode<
11470 ::fidl_next::wire::Vector<'static, crate::wire::PciDevice<'static>>,
11471 ___E,
11472 >,
11473 {
11474 #[inline]
11475 fn encode(
11476 self,
11477 encoder_: &mut ___E,
11478 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugGetDevicesResponse<'static>>,
11479 _: (),
11480 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11481 ::fidl_next::munge! {
11482 let crate::wire::DebugGetDevicesResponse {
11483 devices,
11484
11485 } = out_;
11486 }
11487
11488 ::fidl_next::Encode::encode(self.devices, encoder_, devices, (64, ()))?;
11489
11490 Ok(())
11491 }
11492 }
11493
11494 pub struct DebugReadBarRequest<T0, T1, T2, T3> {
11496 pub device: T0,
11497
11498 pub bar_id: T1,
11499
11500 pub offset: T2,
11501
11502 pub size: T3,
11503 }
11504
11505 unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<crate::wire::DebugReadBarRequest, ___E>
11506 for DebugReadBarRequest<T0, T1, T2, T3>
11507 where
11508 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11509 T0: ::fidl_next::Encode<crate::wire::Address, ___E>,
11510 T1: ::fidl_next::Encode<u8, ___E>,
11511 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11512 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
11513 {
11514 #[inline]
11515 fn encode(
11516 self,
11517 encoder_: &mut ___E,
11518 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarRequest>,
11519 _: (),
11520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11521 ::fidl_next::munge! {
11522 let crate::wire::DebugReadBarRequest {
11523 device,
11524 bar_id,
11525 offset,
11526 size,
11527
11528 } = out_;
11529 }
11530
11531 ::fidl_next::Encode::encode(self.device, encoder_, device, ())?;
11532
11533 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11534
11535 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11536
11537 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
11538
11539 Ok(())
11540 }
11541 }
11542
11543 pub struct DebugReadBarResponse<T0> {
11545 pub buffer: T0,
11546 }
11547
11548 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DebugReadBarResponse<'static>, ___E>
11549 for DebugReadBarResponse<T0>
11550 where
11551 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11552 ___E: ::fidl_next::Encoder,
11553 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
11554 {
11555 #[inline]
11556 fn encode(
11557 self,
11558 encoder_: &mut ___E,
11559 out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugReadBarResponse<'static>>,
11560 _: (),
11561 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11562 ::fidl_next::munge! {
11563 let crate::wire::DebugReadBarResponse {
11564 buffer,
11565
11566 } = out_;
11567 }
11568
11569 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, (4294967295, ()))?;
11570
11571 Ok(())
11572 }
11573 }
11574
11575 pub type Padding = ();
11577
11578 pub struct DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
11580 pub vendor_id: T0,
11581
11582 pub device_id: T1,
11583
11584 pub base_class: T2,
11585
11586 pub sub_class: T3,
11587
11588 pub program_interface: T4,
11589
11590 pub revision_id: T5,
11591
11592 pub bus_id: T6,
11593
11594 pub dev_id: T7,
11595
11596 pub func_id: T8,
11597
11598 pub padding: T9,
11599 }
11600
11601 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11602 ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>
11603 for DeviceInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
11604 where
11605 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11606 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11607 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11608 T2: ::fidl_next::Encode<u8, ___E>,
11609 T3: ::fidl_next::Encode<u8, ___E>,
11610 T4: ::fidl_next::Encode<u8, ___E>,
11611 T5: ::fidl_next::Encode<u8, ___E>,
11612 T6: ::fidl_next::Encode<u8, ___E>,
11613 T7: ::fidl_next::Encode<u8, ___E>,
11614 T8: ::fidl_next::Encode<u8, ___E>,
11615 T9: ::fidl_next::Encode<crate::wire::Padding, ___E>,
11616 {
11617 #[inline]
11618 fn encode(
11619 self,
11620 encoder_: &mut ___E,
11621 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceInfo>,
11622 _: (),
11623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11624 ::fidl_next::munge! {
11625 let crate::wire::DeviceInfo {
11626 vendor_id,
11627 device_id,
11628 base_class,
11629 sub_class,
11630 program_interface,
11631 revision_id,
11632 bus_id,
11633 dev_id,
11634 func_id,
11635 padding,
11636
11637 } = out_;
11638 }
11639
11640 ::fidl_next::Encode::encode(self.vendor_id, encoder_, vendor_id, ())?;
11641
11642 ::fidl_next::Encode::encode(self.device_id, encoder_, device_id, ())?;
11643
11644 ::fidl_next::Encode::encode(self.base_class, encoder_, base_class, ())?;
11645
11646 ::fidl_next::Encode::encode(self.sub_class, encoder_, sub_class, ())?;
11647
11648 ::fidl_next::Encode::encode(self.program_interface, encoder_, program_interface, ())?;
11649
11650 ::fidl_next::Encode::encode(self.revision_id, encoder_, revision_id, ())?;
11651
11652 ::fidl_next::Encode::encode(self.bus_id, encoder_, bus_id, ())?;
11653
11654 ::fidl_next::Encode::encode(self.dev_id, encoder_, dev_id, ())?;
11655
11656 ::fidl_next::Encode::encode(self.func_id, encoder_, func_id, ())?;
11657
11658 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
11659
11660 Ok(())
11661 }
11662 }
11663
11664 pub struct DeviceGetDeviceInfoResponse<T0> {
11666 pub info: T0,
11667 }
11668
11669 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetDeviceInfoResponse, ___E>
11670 for DeviceGetDeviceInfoResponse<T0>
11671 where
11672 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11673 T0: ::fidl_next::Encode<crate::wire::DeviceInfo, ___E>,
11674 {
11675 #[inline]
11676 fn encode(
11677 self,
11678 encoder_: &mut ___E,
11679 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetDeviceInfoResponse>,
11680 _: (),
11681 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11682 ::fidl_next::munge! {
11683 let crate::wire::DeviceGetDeviceInfoResponse {
11684 info,
11685
11686 } = out_;
11687 }
11688
11689 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
11690
11691 Ok(())
11692 }
11693 }
11694
11695 pub struct DeviceGetBarRequest<T0> {
11697 pub bar_id: T0,
11698 }
11699
11700 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBarRequest, ___E>
11701 for DeviceGetBarRequest<T0>
11702 where
11703 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11704 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11705 {
11706 #[inline]
11707 fn encode(
11708 self,
11709 encoder_: &mut ___E,
11710 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBarRequest>,
11711 _: (),
11712 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11713 ::fidl_next::munge! {
11714 let crate::wire::DeviceGetBarRequest {
11715 bar_id,
11716
11717 } = out_;
11718 }
11719
11720 ::fidl_next::Encode::encode(self.bar_id, encoder_, bar_id, ())?;
11721
11722 Ok(())
11723 }
11724 }
11725
11726 pub struct DeviceSetBusMasteringRequest<T0> {
11728 pub enabled: T0,
11729 }
11730
11731 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceSetBusMasteringRequest, ___E>
11732 for DeviceSetBusMasteringRequest<T0>
11733 where
11734 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11735 T0: ::fidl_next::Encode<bool, ___E>,
11736 {
11737 #[inline]
11738 fn encode(
11739 self,
11740 encoder_: &mut ___E,
11741 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetBusMasteringRequest>,
11742 _: (),
11743 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11744 ::fidl_next::munge! {
11745 let crate::wire::DeviceSetBusMasteringRequest {
11746 enabled,
11747
11748 } = out_;
11749 }
11750
11751 ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
11752
11753 Ok(())
11754 }
11755 }
11756
11757 pub type DeviceSetBusMasteringResponse = ();
11759
11760 pub type DeviceResetDeviceResponse = ();
11762
11763 pub type DeviceAckInterruptResponse = ();
11765
11766 pub struct DeviceMapInterruptRequest<T0> {
11768 pub which_irq: T0,
11769 }
11770
11771 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceMapInterruptRequest, ___E>
11772 for DeviceMapInterruptRequest<T0>
11773 where
11774 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11775 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11776 {
11777 #[inline]
11778 fn encode(
11779 self,
11780 encoder_: &mut ___E,
11781 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceMapInterruptRequest>,
11782 _: (),
11783 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11784 ::fidl_next::munge! {
11785 let crate::wire::DeviceMapInterruptRequest {
11786 which_irq,
11787
11788 } = out_;
11789 }
11790
11791 ::fidl_next::Encode::encode(self.which_irq, encoder_, which_irq, ())?;
11792
11793 Ok(())
11794 }
11795 }
11796
11797 pub struct InterruptModes<T0, T1, T2> {
11799 pub has_legacy: T0,
11800
11801 pub msi_count: T1,
11802
11803 pub msix_count: T2,
11804 }
11805
11806 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::InterruptModes, ___E>
11807 for InterruptModes<T0, T1, T2>
11808 where
11809 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11810 T0: ::fidl_next::Encode<bool, ___E>,
11811 T1: ::fidl_next::Encode<u8, ___E>,
11812 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11813 {
11814 #[inline]
11815 fn encode(
11816 self,
11817 encoder_: &mut ___E,
11818 out_: &mut ::core::mem::MaybeUninit<crate::wire::InterruptModes>,
11819 _: (),
11820 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11821 ::fidl_next::munge! {
11822 let crate::wire::InterruptModes {
11823 has_legacy,
11824 msi_count,
11825 msix_count,
11826
11827 } = out_;
11828 }
11829
11830 ::fidl_next::Encode::encode(self.has_legacy, encoder_, has_legacy, ())?;
11831
11832 ::fidl_next::Encode::encode(self.msi_count, encoder_, msi_count, ())?;
11833
11834 ::fidl_next::Encode::encode(self.msix_count, encoder_, msix_count, ())?;
11835
11836 Ok(())
11837 }
11838 }
11839
11840 pub struct DeviceGetInterruptModesResponse<T0> {
11842 pub modes: T0,
11843 }
11844
11845 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetInterruptModesResponse, ___E>
11846 for DeviceGetInterruptModesResponse<T0>
11847 where
11848 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11849 T0: ::fidl_next::Encode<crate::wire::InterruptModes, ___E>,
11850 {
11851 #[inline]
11852 fn encode(
11853 self,
11854 encoder_: &mut ___E,
11855 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetInterruptModesResponse>,
11856 _: (),
11857 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11858 ::fidl_next::munge! {
11859 let crate::wire::DeviceGetInterruptModesResponse {
11860 modes,
11861
11862 } = out_;
11863 }
11864
11865 ::fidl_next::Encode::encode(self.modes, encoder_, modes, ())?;
11866
11867 Ok(())
11868 }
11869 }
11870
11871 pub struct DeviceSetInterruptModeRequest<T0, T1> {
11873 pub mode: T0,
11874
11875 pub requested_irq_count: T1,
11876 }
11877
11878 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceSetInterruptModeRequest, ___E>
11879 for DeviceSetInterruptModeRequest<T0, T1>
11880 where
11881 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11882 T0: ::fidl_next::Encode<crate::wire::InterruptMode, ___E>,
11883 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
11884 {
11885 #[inline]
11886 fn encode(
11887 self,
11888 encoder_: &mut ___E,
11889 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSetInterruptModeRequest>,
11890 _: (),
11891 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11892 ::fidl_next::munge! {
11893 let crate::wire::DeviceSetInterruptModeRequest {
11894 mode,
11895 requested_irq_count,
11896
11897 } = out_;
11898 }
11899
11900 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
11901
11902 ::fidl_next::Encode::encode(
11903 self.requested_irq_count,
11904 encoder_,
11905 requested_irq_count,
11906 (),
11907 )?;
11908
11909 Ok(())
11910 }
11911 }
11912
11913 pub type DeviceSetInterruptModeResponse = ();
11915
11916 pub struct DeviceReadConfig8Request<T0> {
11918 pub offset: T0,
11919 }
11920
11921 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Request, ___E>
11922 for DeviceReadConfig8Request<T0>
11923 where
11924 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11925 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11926 {
11927 #[inline]
11928 fn encode(
11929 self,
11930 encoder_: &mut ___E,
11931 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Request>,
11932 _: (),
11933 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11934 ::fidl_next::munge! {
11935 let crate::wire::DeviceReadConfig8Request {
11936 offset,
11937
11938 } = out_;
11939 }
11940
11941 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
11942
11943 Ok(())
11944 }
11945 }
11946
11947 pub struct DeviceReadConfig8Response<T0> {
11949 pub value: T0,
11950 }
11951
11952 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig8Response, ___E>
11953 for DeviceReadConfig8Response<T0>
11954 where
11955 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11956 T0: ::fidl_next::Encode<u8, ___E>,
11957 {
11958 #[inline]
11959 fn encode(
11960 self,
11961 encoder_: &mut ___E,
11962 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig8Response>,
11963 _: (),
11964 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11965 ::fidl_next::munge! {
11966 let crate::wire::DeviceReadConfig8Response {
11967 value,
11968
11969 } = out_;
11970 }
11971
11972 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
11973
11974 Ok(())
11975 }
11976 }
11977
11978 pub struct DeviceReadConfig16Request<T0> {
11980 pub offset: T0,
11981 }
11982
11983 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Request, ___E>
11984 for DeviceReadConfig16Request<T0>
11985 where
11986 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11987 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
11988 {
11989 #[inline]
11990 fn encode(
11991 self,
11992 encoder_: &mut ___E,
11993 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Request>,
11994 _: (),
11995 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11996 ::fidl_next::munge! {
11997 let crate::wire::DeviceReadConfig16Request {
11998 offset,
11999
12000 } = out_;
12001 }
12002
12003 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
12004
12005 Ok(())
12006 }
12007 }
12008
12009 pub struct DeviceReadConfig16Response<T0> {
12011 pub value: T0,
12012 }
12013
12014 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig16Response, ___E>
12015 for DeviceReadConfig16Response<T0>
12016 where
12017 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12018 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12019 {
12020 #[inline]
12021 fn encode(
12022 self,
12023 encoder_: &mut ___E,
12024 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig16Response>,
12025 _: (),
12026 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12027 ::fidl_next::munge! {
12028 let crate::wire::DeviceReadConfig16Response {
12029 value,
12030
12031 } = out_;
12032 }
12033
12034 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
12035
12036 Ok(())
12037 }
12038 }
12039
12040 pub struct DeviceReadConfig32Request<T0> {
12042 pub offset: T0,
12043 }
12044
12045 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Request, ___E>
12046 for DeviceReadConfig32Request<T0>
12047 where
12048 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12049 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12050 {
12051 #[inline]
12052 fn encode(
12053 self,
12054 encoder_: &mut ___E,
12055 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Request>,
12056 _: (),
12057 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12058 ::fidl_next::munge! {
12059 let crate::wire::DeviceReadConfig32Request {
12060 offset,
12061
12062 } = out_;
12063 }
12064
12065 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
12066
12067 Ok(())
12068 }
12069 }
12070
12071 pub struct DeviceReadConfig32Response<T0> {
12073 pub value: T0,
12074 }
12075
12076 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceReadConfig32Response, ___E>
12077 for DeviceReadConfig32Response<T0>
12078 where
12079 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12080 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
12081 {
12082 #[inline]
12083 fn encode(
12084 self,
12085 encoder_: &mut ___E,
12086 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceReadConfig32Response>,
12087 _: (),
12088 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12089 ::fidl_next::munge! {
12090 let crate::wire::DeviceReadConfig32Response {
12091 value,
12092
12093 } = out_;
12094 }
12095
12096 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
12097
12098 Ok(())
12099 }
12100 }
12101
12102 pub struct DeviceWriteConfig8Request<T0, T1> {
12104 pub offset: T0,
12105
12106 pub value: T1,
12107 }
12108
12109 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig8Request, ___E>
12110 for DeviceWriteConfig8Request<T0, T1>
12111 where
12112 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12113 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12114 T1: ::fidl_next::Encode<u8, ___E>,
12115 {
12116 #[inline]
12117 fn encode(
12118 self,
12119 encoder_: &mut ___E,
12120 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig8Request>,
12121 _: (),
12122 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12123 ::fidl_next::munge! {
12124 let crate::wire::DeviceWriteConfig8Request {
12125 offset,
12126 value,
12127
12128 } = out_;
12129 }
12130
12131 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
12132
12133 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
12134
12135 Ok(())
12136 }
12137 }
12138
12139 pub type DeviceWriteConfig8Response = ();
12141
12142 pub struct DeviceWriteConfig16Request<T0, T1> {
12144 pub offset: T0,
12145
12146 pub value: T1,
12147 }
12148
12149 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig16Request, ___E>
12150 for DeviceWriteConfig16Request<T0, T1>
12151 where
12152 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12153 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12154 T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12155 {
12156 #[inline]
12157 fn encode(
12158 self,
12159 encoder_: &mut ___E,
12160 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig16Request>,
12161 _: (),
12162 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12163 ::fidl_next::munge! {
12164 let crate::wire::DeviceWriteConfig16Request {
12165 offset,
12166 value,
12167
12168 } = out_;
12169 }
12170
12171 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
12172
12173 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
12174
12175 Ok(())
12176 }
12177 }
12178
12179 pub type DeviceWriteConfig16Response = ();
12181
12182 pub struct DeviceWriteConfig32Request<T0, T1> {
12184 pub offset: T0,
12185
12186 pub value: T1,
12187 }
12188
12189 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DeviceWriteConfig32Request, ___E>
12190 for DeviceWriteConfig32Request<T0, T1>
12191 where
12192 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12193 T0: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
12194 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
12195 {
12196 #[inline]
12197 fn encode(
12198 self,
12199 encoder_: &mut ___E,
12200 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceWriteConfig32Request>,
12201 _: (),
12202 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12203 ::fidl_next::munge! {
12204 let crate::wire::DeviceWriteConfig32Request {
12205 offset,
12206 value,
12207
12208 } = out_;
12209 }
12210
12211 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
12212
12213 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
12214
12215 Ok(())
12216 }
12217 }
12218
12219 pub type DeviceWriteConfig32Response = ();
12221
12222 pub struct DeviceGetCapabilitiesRequest<T0> {
12224 pub id: T0,
12225 }
12226
12227 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesRequest, ___E>
12228 for DeviceGetCapabilitiesRequest<T0>
12229 where
12230 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12231 T0: ::fidl_next::Encode<crate::wire::CapabilityId, ___E>,
12232 {
12233 #[inline]
12234 fn encode(
12235 self,
12236 encoder_: &mut ___E,
12237 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetCapabilitiesRequest>,
12238 _: (),
12239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12240 ::fidl_next::munge! {
12241 let crate::wire::DeviceGetCapabilitiesRequest {
12242 id,
12243
12244 } = out_;
12245 }
12246
12247 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
12248
12249 Ok(())
12250 }
12251 }
12252
12253 pub struct DeviceGetCapabilitiesResponse<T0> {
12255 pub offsets: T0,
12256 }
12257
12258 unsafe impl<___E, T0>
12259 ::fidl_next::Encode<crate::wire::DeviceGetCapabilitiesResponse<'static>, ___E>
12260 for DeviceGetCapabilitiesResponse<T0>
12261 where
12262 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12263 ___E: ::fidl_next::Encoder,
12264 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
12265 {
12266 #[inline]
12267 fn encode(
12268 self,
12269 encoder_: &mut ___E,
12270 out_: &mut ::core::mem::MaybeUninit<
12271 crate::wire::DeviceGetCapabilitiesResponse<'static>,
12272 >,
12273 _: (),
12274 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12275 ::fidl_next::munge! {
12276 let crate::wire::DeviceGetCapabilitiesResponse {
12277 offsets,
12278
12279 } = out_;
12280 }
12281
12282 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
12283
12284 Ok(())
12285 }
12286 }
12287
12288 pub struct DeviceGetExtendedCapabilitiesRequest<T0> {
12290 pub id: T0,
12291 }
12292
12293 unsafe impl<___E, T0>
12294 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesRequest, ___E>
12295 for DeviceGetExtendedCapabilitiesRequest<T0>
12296 where
12297 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12298 T0: ::fidl_next::Encode<crate::wire::ExtendedCapabilityId, ___E>,
12299 {
12300 #[inline]
12301 fn encode(
12302 self,
12303 encoder_: &mut ___E,
12304 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetExtendedCapabilitiesRequest>,
12305 _: (),
12306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12307 ::fidl_next::munge! {
12308 let crate::wire::DeviceGetExtendedCapabilitiesRequest {
12309 id,
12310
12311 } = out_;
12312 }
12313
12314 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
12315
12316 Ok(())
12317 }
12318 }
12319
12320 pub struct DeviceGetExtendedCapabilitiesResponse<T0> {
12322 pub offsets: T0,
12323 }
12324
12325 unsafe impl<___E, T0>
12326 ::fidl_next::Encode<crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>, ___E>
12327 for DeviceGetExtendedCapabilitiesResponse<T0>
12328 where
12329 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12330 ___E: ::fidl_next::Encoder,
12331 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>, ___E>,
12332 {
12333 #[inline]
12334 fn encode(
12335 self,
12336 encoder_: &mut ___E,
12337 out_: &mut ::core::mem::MaybeUninit<
12338 crate::wire::DeviceGetExtendedCapabilitiesResponse<'static>,
12339 >,
12340 _: (),
12341 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12342 ::fidl_next::munge! {
12343 let crate::wire::DeviceGetExtendedCapabilitiesResponse {
12344 offsets,
12345
12346 } = out_;
12347 }
12348
12349 ::fidl_next::Encode::encode(self.offsets, encoder_, offsets, (32, ()))?;
12350
12351 Ok(())
12352 }
12353 }
12354
12355 pub struct DeviceGetBtiRequest<T0> {
12357 pub index: T0,
12358 }
12359
12360 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetBtiRequest, ___E>
12361 for DeviceGetBtiRequest<T0>
12362 where
12363 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12364 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
12365 {
12366 #[inline]
12367 fn encode(
12368 self,
12369 encoder_: &mut ___E,
12370 out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetBtiRequest>,
12371 _: (),
12372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12373 ::fidl_next::munge! {
12374 let crate::wire::DeviceGetBtiRequest {
12375 index,
12376
12377 } = out_;
12378 }
12379
12380 ::fidl_next::Encode::encode(self.index, encoder_, index, ())?;
12381
12382 Ok(())
12383 }
12384 }
12385}
12386
12387pub use self::natural::*;
12388
12389pub const BASE_ADDRESS_COUNT: u32 = 6 as u32;
12390
12391#[doc = " Per the PCI specification.\n"]
12392pub const BASE_CONFIG_SIZE: u32 = 256 as u32;
12393
12394pub const MAX_NAME_LEN: u32 = 32 as u32;
12395
12396pub const MAX_CAPABILITIES: u32 = 32 as u32;
12397
12398pub const MAX_EXT_CAPABILITIES: u32 = 32 as u32;
12399
12400#[doc = " At the time of writing, a Device is 571 bytes.\n"]
12401pub const MAX_DEVICES: u32 = 64 as u32;
12402
12403#[doc = " The Debug protocol provides information about devices on a particular bus.\n It is used for tools like lspci and not for driver operations.\n"]
12405#[derive(PartialEq, Debug)]
12406pub struct Debug;
12407
12408impl ::fidl_next::Discoverable for Debug {
12409 const PROTOCOL_NAME: &'static str = "fuchsia.hardware.pci.Debug";
12410}
12411
12412#[cfg(target_os = "fuchsia")]
12413impl ::fidl_next::HasTransport for Debug {
12414 type Transport = ::fidl_next::fuchsia::zx::Channel;
12415}
12416
12417pub mod debug {
12418 pub mod prelude {
12419 pub use crate::{
12420 Debug, DebugClientHandler, DebugLocalClientHandler, DebugLocalServerHandler,
12421 DebugServerHandler, debug,
12422 };
12423
12424 pub use crate::natural::DebugGetDevicesResponse;
12425
12426 pub use crate::natural::DebugGetHostBridgeInfoResponse;
12427
12428 pub use crate::natural::DebugReadBarRequest;
12429
12430 pub use crate::natural::DebugReadBarResponse;
12431 }
12432
12433 pub struct GetHostBridgeInfo;
12434
12435 impl ::fidl_next::Method for GetHostBridgeInfo {
12436 const ORDINAL: u64 = 3152463001312932177;
12437 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12438 ::fidl_next::protocol::Flexibility::Strict;
12439
12440 type Protocol = crate::Debug;
12441
12442 type Request = ::fidl_next::wire::EmptyMessageBody;
12443 }
12444
12445 impl ::fidl_next::TwoWayMethod for GetHostBridgeInfo {
12446 type Response =
12447 ::fidl_next::wire::Strict<crate::wire::DebugGetHostBridgeInfoResponse<'static>>;
12448 }
12449
12450 impl<___R> ::fidl_next::Respond<___R> for GetHostBridgeInfo {
12451 type Output = ::fidl_next::Strict<crate::generic::DebugGetHostBridgeInfoResponse<___R>>;
12452
12453 fn respond(response: ___R) -> Self::Output {
12454 ::fidl_next::Strict(crate::generic::DebugGetHostBridgeInfoResponse { info: response })
12455 }
12456 }
12457
12458 pub struct GetDevices;
12459
12460 impl ::fidl_next::Method for GetDevices {
12461 const ORDINAL: u64 = 8781583428551734162;
12462 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12463 ::fidl_next::protocol::Flexibility::Strict;
12464
12465 type Protocol = crate::Debug;
12466
12467 type Request = ::fidl_next::wire::EmptyMessageBody;
12468 }
12469
12470 impl ::fidl_next::TwoWayMethod for GetDevices {
12471 type Response = ::fidl_next::wire::Strict<crate::wire::DebugGetDevicesResponse<'static>>;
12472 }
12473
12474 impl<___R> ::fidl_next::Respond<___R> for GetDevices {
12475 type Output = ::fidl_next::Strict<crate::generic::DebugGetDevicesResponse<___R>>;
12476
12477 fn respond(response: ___R) -> Self::Output {
12478 ::fidl_next::Strict(crate::generic::DebugGetDevicesResponse { devices: response })
12479 }
12480 }
12481
12482 pub struct ReadBar;
12483
12484 impl ::fidl_next::Method for ReadBar {
12485 const ORDINAL: u64 = 3920714022630704052;
12486 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12487 ::fidl_next::protocol::Flexibility::Strict;
12488
12489 type Protocol = crate::Debug;
12490
12491 type Request = crate::wire::DebugReadBarRequest;
12492 }
12493
12494 impl ::fidl_next::TwoWayMethod for ReadBar {
12495 type Response = ::fidl_next::wire::Result<
12496 'static,
12497 crate::wire::DebugReadBarResponse<'static>,
12498 ::fidl_next::wire::fuchsia::Status,
12499 >;
12500 }
12501
12502 impl<___R> ::fidl_next::Respond<___R> for ReadBar {
12503 type Output = ::core::result::Result<
12504 crate::generic::DebugReadBarResponse<___R>,
12505 ::fidl_next::never::Never,
12506 >;
12507
12508 fn respond(response: ___R) -> Self::Output {
12509 ::core::result::Result::Ok(crate::generic::DebugReadBarResponse { buffer: response })
12510 }
12511 }
12512
12513 impl<___R> ::fidl_next::RespondErr<___R> for ReadBar {
12514 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12515
12516 fn respond_err(response: ___R) -> Self::Output {
12517 ::core::result::Result::Err(response)
12518 }
12519 }
12520
12521 mod ___detail {
12522 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Debug
12523 where
12524 ___T: ::fidl_next::Transport,
12525 {
12526 type Client = DebugClient<___T>;
12527 type Server = DebugServer<___T>;
12528 }
12529
12530 #[repr(transparent)]
12532 pub struct DebugClient<___T: ::fidl_next::Transport> {
12533 #[allow(dead_code)]
12534 client: ::fidl_next::protocol::Client<___T>,
12535 }
12536
12537 impl<___T> DebugClient<___T>
12538 where
12539 ___T: ::fidl_next::Transport,
12540 {
12541 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12542 pub fn get_host_bridge_info(
12543 &self,
12544 ) -> ::fidl_next::TwoWayFuture<'_, super::GetHostBridgeInfo, ___T> {
12545 ::fidl_next::TwoWayFuture::from_untyped(
12546 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12547 3152463001312932177,
12548 <super::GetHostBridgeInfo as ::fidl_next::Method>::FLEXIBILITY,
12549 (),
12550 ),
12551 )
12552 }
12553
12554 #[doc = " Retrieve all Devices on the Bus.\n"]
12555 pub fn get_devices(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetDevices, ___T> {
12556 ::fidl_next::TwoWayFuture::from_untyped(
12557 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12558 8781583428551734162,
12559 <super::GetDevices as ::fidl_next::Method>::FLEXIBILITY,
12560 (),
12561 ),
12562 )
12563 }
12564
12565 #[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"]
12566 pub fn read_bar(
12567 &self,
12568
12569 device: impl ::fidl_next::Encode<
12570 crate::wire::Address,
12571 <___T as ::fidl_next::Transport>::SendBuffer,
12572 >,
12573
12574 bar_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
12575
12576 offset: impl ::fidl_next::Encode<
12577 ::fidl_next::wire::Uint64,
12578 <___T as ::fidl_next::Transport>::SendBuffer,
12579 >,
12580
12581 size: impl ::fidl_next::Encode<
12582 ::fidl_next::wire::Uint64,
12583 <___T as ::fidl_next::Transport>::SendBuffer,
12584 >,
12585 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12586 where
12587 <___T as ::fidl_next::Transport>::SendBuffer:
12588 ::fidl_next::encoder::InternalHandleEncoder,
12589 {
12590 self.read_bar_with(crate::generic::DebugReadBarRequest {
12591 device,
12592
12593 bar_id,
12594
12595 offset,
12596
12597 size,
12598 })
12599 }
12600
12601 #[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"]
12602 pub fn read_bar_with<___R>(
12603 &self,
12604 request: ___R,
12605 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadBar, ___T>
12606 where
12607 ___R: ::fidl_next::Encode<
12608 crate::wire::DebugReadBarRequest,
12609 <___T as ::fidl_next::Transport>::SendBuffer,
12610 >,
12611 {
12612 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12613 3920714022630704052,
12614 <super::ReadBar as ::fidl_next::Method>::FLEXIBILITY,
12615 request,
12616 ))
12617 }
12618 }
12619
12620 #[repr(transparent)]
12622 pub struct DebugServer<___T: ::fidl_next::Transport> {
12623 server: ::fidl_next::protocol::Server<___T>,
12624 }
12625
12626 impl<___T> DebugServer<___T> where ___T: ::fidl_next::Transport {}
12627 }
12628}
12629
12630#[diagnostic::on_unimplemented(
12631 note = "If {Self} implements the non-local DebugClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12632)]
12633
12634pub trait DebugLocalClientHandler<
12638 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12639 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12640>
12641{
12642}
12643
12644impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Debug
12645where
12646 ___H: DebugLocalClientHandler<___T>,
12647 ___T: ::fidl_next::Transport,
12648{
12649 async fn on_event(
12650 handler: &mut ___H,
12651 mut message: ::fidl_next::Message<___T>,
12652 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12653 match *message.header().ordinal {
12654 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12655 }
12656 }
12657}
12658
12659#[diagnostic::on_unimplemented(
12660 note = "If {Self} implements the non-local DebugServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12661)]
12662
12663pub trait DebugLocalServerHandler<
12667 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12668 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12669>
12670{
12671 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12672 fn get_host_bridge_info(
12673 &mut self,
12674
12675 responder: ::fidl_next::Responder<debug::GetHostBridgeInfo, ___T>,
12676 ) -> impl ::core::future::Future<Output = ()>;
12677
12678 #[doc = " Retrieve all Devices on the Bus.\n"]
12679 fn get_devices(
12680 &mut self,
12681
12682 responder: ::fidl_next::Responder<debug::GetDevices, ___T>,
12683 ) -> impl ::core::future::Future<Output = ()>;
12684
12685 #[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"]
12686 fn read_bar(
12687 &mut self,
12688
12689 request: ::fidl_next::Request<debug::ReadBar, ___T>,
12690
12691 responder: ::fidl_next::Responder<debug::ReadBar, ___T>,
12692 ) -> impl ::core::future::Future<Output = ()>;
12693}
12694
12695impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Debug
12696where
12697 ___H: DebugLocalServerHandler<___T>,
12698 ___T: ::fidl_next::Transport,
12699 for<'de> crate::wire::DebugReadBarRequest: ::fidl_next::Decode<
12700 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12701 Constraint = (),
12702 >,
12703{
12704 async fn on_one_way(
12705 handler: &mut ___H,
12706 mut message: ::fidl_next::Message<___T>,
12707 ) -> ::core::result::Result<
12708 (),
12709 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12710 > {
12711 match *message.header().ordinal {
12712 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12713 }
12714 }
12715
12716 async fn on_two_way(
12717 handler: &mut ___H,
12718 mut message: ::fidl_next::Message<___T>,
12719 responder: ::fidl_next::protocol::Responder<___T>,
12720 ) -> ::core::result::Result<
12721 (),
12722 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12723 > {
12724 match *message.header().ordinal {
12725 3152463001312932177 => {
12726 let responder = ::fidl_next::Responder::from_untyped(responder);
12727
12728 handler.get_host_bridge_info(responder).await;
12729 Ok(())
12730 }
12731
12732 8781583428551734162 => {
12733 let responder = ::fidl_next::Responder::from_untyped(responder);
12734
12735 handler.get_devices(responder).await;
12736 Ok(())
12737 }
12738
12739 3920714022630704052 => {
12740 let responder = ::fidl_next::Responder::from_untyped(responder);
12741
12742 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12743 Ok(decoded) => {
12744 handler
12745 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12746 .await;
12747 Ok(())
12748 }
12749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12750 ordinal: 3920714022630704052,
12751 error,
12752 }),
12753 }
12754 }
12755
12756 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12757 }
12758 }
12759}
12760
12761pub trait DebugClientHandler<
12765 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12766 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12767>
12768{
12769}
12770
12771impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Debug
12772where
12773 ___H: DebugClientHandler<___T> + ::core::marker::Send,
12774 ___T: ::fidl_next::Transport,
12775{
12776 async fn on_event(
12777 handler: &mut ___H,
12778 mut message: ::fidl_next::Message<___T>,
12779 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12780 match *message.header().ordinal {
12781 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12782 }
12783 }
12784}
12785
12786pub trait DebugServerHandler<
12790 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12791 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12792>
12793{
12794 #[doc = " Retrieve information about the segment group and buses covered by a Bus.\n"]
12795 fn get_host_bridge_info(
12796 &mut self,
12797
12798 responder: ::fidl_next::Responder<debug::GetHostBridgeInfo, ___T>,
12799 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12800
12801 #[doc = " Retrieve all Devices on the Bus.\n"]
12802 fn get_devices(
12803 &mut self,
12804
12805 responder: ::fidl_next::Responder<debug::GetDevices, ___T>,
12806 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12807
12808 #[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"]
12809 fn read_bar(
12810 &mut self,
12811
12812 request: ::fidl_next::Request<debug::ReadBar, ___T>,
12813
12814 responder: ::fidl_next::Responder<debug::ReadBar, ___T>,
12815 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12816}
12817
12818impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Debug
12819where
12820 ___H: DebugServerHandler<___T> + ::core::marker::Send,
12821 ___T: ::fidl_next::Transport,
12822 for<'de> crate::wire::DebugReadBarRequest: ::fidl_next::Decode<
12823 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12824 Constraint = (),
12825 >,
12826{
12827 async fn on_one_way(
12828 handler: &mut ___H,
12829 mut message: ::fidl_next::Message<___T>,
12830 ) -> ::core::result::Result<
12831 (),
12832 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12833 > {
12834 match *message.header().ordinal {
12835 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12836 }
12837 }
12838
12839 async fn on_two_way(
12840 handler: &mut ___H,
12841 mut message: ::fidl_next::Message<___T>,
12842 responder: ::fidl_next::protocol::Responder<___T>,
12843 ) -> ::core::result::Result<
12844 (),
12845 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12846 > {
12847 match *message.header().ordinal {
12848 3152463001312932177 => {
12849 let responder = ::fidl_next::Responder::from_untyped(responder);
12850
12851 handler.get_host_bridge_info(responder).await;
12852 Ok(())
12853 }
12854
12855 8781583428551734162 => {
12856 let responder = ::fidl_next::Responder::from_untyped(responder);
12857
12858 handler.get_devices(responder).await;
12859 Ok(())
12860 }
12861
12862 3920714022630704052 => {
12863 let responder = ::fidl_next::Responder::from_untyped(responder);
12864
12865 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12866 Ok(decoded) => {
12867 handler
12868 .read_bar(::fidl_next::Request::from_decoded(decoded), responder)
12869 .await;
12870 Ok(())
12871 }
12872 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12873 ordinal: 3920714022630704052,
12874 error,
12875 }),
12876 }
12877 }
12878
12879 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12880 }
12881 }
12882}
12883
12884impl<___T> DebugClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
12885
12886impl<___H, ___T> DebugLocalClientHandler<___T> for ::fidl_next::Local<___H>
12887where
12888 ___H: DebugClientHandler<___T>,
12889 ___T: ::fidl_next::Transport,
12890{
12891}
12892
12893impl<___H, ___T> DebugLocalServerHandler<___T> for ::fidl_next::Local<___H>
12894where
12895 ___H: DebugServerHandler<___T>,
12896 ___T: ::fidl_next::Transport,
12897{
12898 async fn get_host_bridge_info(
12899 &mut self,
12900
12901 responder: ::fidl_next::Responder<debug::GetHostBridgeInfo, ___T>,
12902 ) {
12903 ___H::get_host_bridge_info(&mut self.0, responder).await
12904 }
12905
12906 async fn get_devices(&mut self, responder: ::fidl_next::Responder<debug::GetDevices, ___T>) {
12907 ___H::get_devices(&mut self.0, responder).await
12908 }
12909
12910 async fn read_bar(
12911 &mut self,
12912
12913 request: ::fidl_next::Request<debug::ReadBar, ___T>,
12914
12915 responder: ::fidl_next::Responder<debug::ReadBar, ___T>,
12916 ) {
12917 ___H::read_bar(&mut self.0, request, responder).await
12918 }
12919}
12920
12921pub const EXTENDED_CONFIG_SIZE: u32 = 4096 as u32;
12922
12923#[doc = " Legacy interrupt pins INTA through INTD.\n"]
12924pub const LEGACY_INTERRUPT_COUNT: u8 = 4 as u8;
12925
12926pub const MAX_BAR_COUNT: u8 = 6 as u8;
12927
12928pub const READBAR_MAX_SIZE: u32 = 1024 as u32;
12929
12930pub const STATUS_DEVSEL_MASK: crate::natural::Status =
12931 crate::natural::Status::from_bits_retain(1536);