1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_hardware_sdmmc::natural::*;
8
9 #[derive(Debug, PartialEq)]
10 #[repr(C)]
11 pub struct CqhciInitializeCommandQueueingRequest {
12 pub virtual_interrupt: ::fidl_next::fuchsia::zx::Interrupt,
13
14 pub virtual_interrupt_lifeline: ::fidl_next::fuchsia::zx::EventPair,
15 }
16
17 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingRequest, ___E>
18 for CqhciInitializeCommandQueueingRequest
19 where
20 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
21 ___E: ::fidl_next::fuchsia::HandleEncoder,
22 {
23 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
24 Self,
25 crate::wire::CqhciInitializeCommandQueueingRequest,
26 > = unsafe {
27 ::fidl_next::CopyOptimization::enable_if(
28 true && <::fidl_next::fuchsia::zx::Interrupt as ::fidl_next::Encode<
29 ::fidl_next::wire::fuchsia::Interrupt,
30 ___E,
31 >>::COPY_OPTIMIZATION
32 .is_enabled()
33 && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
34 ::fidl_next::wire::fuchsia::EventPair,
35 ___E,
36 >>::COPY_OPTIMIZATION
37 .is_enabled(),
38 )
39 };
40
41 #[inline]
42 fn encode(
43 self,
44 encoder_: &mut ___E,
45 out_: &mut ::core::mem::MaybeUninit<crate::wire::CqhciInitializeCommandQueueingRequest>,
46 _: (),
47 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
48 ::fidl_next::munge! {
49 let crate::wire::CqhciInitializeCommandQueueingRequest {
50 virtual_interrupt,
51 virtual_interrupt_lifeline,
52
53 } = out_;
54 }
55
56 ::fidl_next::Encode::encode(self.virtual_interrupt, encoder_, virtual_interrupt, ())?;
57
58 let mut _field =
59 unsafe { ::fidl_next::Slot::new_unchecked(virtual_interrupt.as_mut_ptr()) };
60
61 ::fidl_next::Encode::encode(
62 self.virtual_interrupt_lifeline,
63 encoder_,
64 virtual_interrupt_lifeline,
65 (),
66 )?;
67
68 let mut _field = unsafe {
69 ::fidl_next::Slot::new_unchecked(virtual_interrupt_lifeline.as_mut_ptr())
70 };
71
72 Ok(())
73 }
74 }
75
76 unsafe impl<___E>
77 ::fidl_next::EncodeOption<
78 ::fidl_next::wire::Box<'static, crate::wire::CqhciInitializeCommandQueueingRequest>,
79 ___E,
80 > for CqhciInitializeCommandQueueingRequest
81 where
82 ___E: ::fidl_next::Encoder + ?Sized,
83 CqhciInitializeCommandQueueingRequest:
84 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingRequest, ___E>,
85 {
86 #[inline]
87 fn encode_option(
88 this: ::core::option::Option<Self>,
89 encoder: &mut ___E,
90 out: &mut ::core::mem::MaybeUninit<
91 ::fidl_next::wire::Box<'static, crate::wire::CqhciInitializeCommandQueueingRequest>,
92 >,
93 _: (),
94 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
95 if let Some(inner) = this {
96 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
97 ::fidl_next::wire::Box::encode_present(out);
98 } else {
99 ::fidl_next::wire::Box::encode_absent(out);
100 }
101
102 Ok(())
103 }
104 }
105
106 impl ::fidl_next::FromWire<crate::wire::CqhciInitializeCommandQueueingRequest>
107 for CqhciInitializeCommandQueueingRequest
108 {
109 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
110 crate::wire::CqhciInitializeCommandQueueingRequest,
111 Self,
112 > = unsafe {
113 ::fidl_next::CopyOptimization::enable_if(
114 true && <::fidl_next::fuchsia::zx::Interrupt as ::fidl_next::FromWire<
115 ::fidl_next::wire::fuchsia::Interrupt,
116 >>::COPY_OPTIMIZATION
117 .is_enabled()
118 && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
119 ::fidl_next::wire::fuchsia::EventPair,
120 >>::COPY_OPTIMIZATION
121 .is_enabled(),
122 )
123 };
124
125 #[inline]
126 fn from_wire(wire: crate::wire::CqhciInitializeCommandQueueingRequest) -> Self {
127 Self {
128 virtual_interrupt: ::fidl_next::FromWire::from_wire(wire.virtual_interrupt),
129
130 virtual_interrupt_lifeline: ::fidl_next::FromWire::from_wire(
131 wire.virtual_interrupt_lifeline,
132 ),
133 }
134 }
135 }
136
137 #[derive(Debug, PartialEq)]
138 pub struct CqhciInitializeCommandQueueingResponse {
139 pub cqhci_mmio: ::fidl_next::fuchsia::zx::Vmo,
140
141 pub cqhci_mmio_offset: u64,
142
143 pub sdhci_mmio: ::fidl_next::fuchsia::zx::Vmo,
144
145 pub sdhci_mmio_offset: u64,
146
147 pub bti: ::fidl_next::fuchsia::zx::Bti,
148
149 pub interrupt: ::fidl_next::fuchsia::zx::Interrupt,
150 }
151
152 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingResponse, ___E>
153 for CqhciInitializeCommandQueueingResponse
154 where
155 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
156 ___E: ::fidl_next::fuchsia::HandleEncoder,
157 {
158 #[inline]
159 fn encode(
160 self,
161 encoder_: &mut ___E,
162 out_: &mut ::core::mem::MaybeUninit<
163 crate::wire::CqhciInitializeCommandQueueingResponse,
164 >,
165 _: (),
166 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
167 ::fidl_next::munge! {
168 let crate::wire::CqhciInitializeCommandQueueingResponse {
169 cqhci_mmio,
170 cqhci_mmio_offset,
171 sdhci_mmio,
172 sdhci_mmio_offset,
173 bti,
174 interrupt,
175
176 } = out_;
177 }
178
179 ::fidl_next::Encode::encode(self.cqhci_mmio, encoder_, cqhci_mmio, ())?;
180
181 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(cqhci_mmio.as_mut_ptr()) };
182
183 ::fidl_next::Encode::encode(self.cqhci_mmio_offset, encoder_, cqhci_mmio_offset, ())?;
184
185 let mut _field =
186 unsafe { ::fidl_next::Slot::new_unchecked(cqhci_mmio_offset.as_mut_ptr()) };
187
188 ::fidl_next::Encode::encode(self.sdhci_mmio, encoder_, sdhci_mmio, ())?;
189
190 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sdhci_mmio.as_mut_ptr()) };
191
192 ::fidl_next::Encode::encode(self.sdhci_mmio_offset, encoder_, sdhci_mmio_offset, ())?;
193
194 let mut _field =
195 unsafe { ::fidl_next::Slot::new_unchecked(sdhci_mmio_offset.as_mut_ptr()) };
196
197 ::fidl_next::Encode::encode(self.bti, encoder_, bti, ())?;
198
199 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bti.as_mut_ptr()) };
200
201 ::fidl_next::Encode::encode(self.interrupt, encoder_, interrupt, ())?;
202
203 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(interrupt.as_mut_ptr()) };
204
205 Ok(())
206 }
207 }
208
209 unsafe impl<___E>
210 ::fidl_next::EncodeOption<
211 ::fidl_next::wire::Box<'static, crate::wire::CqhciInitializeCommandQueueingResponse>,
212 ___E,
213 > for CqhciInitializeCommandQueueingResponse
214 where
215 ___E: ::fidl_next::Encoder + ?Sized,
216 CqhciInitializeCommandQueueingResponse:
217 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingResponse, ___E>,
218 {
219 #[inline]
220 fn encode_option(
221 this: ::core::option::Option<Self>,
222 encoder: &mut ___E,
223 out: &mut ::core::mem::MaybeUninit<
224 ::fidl_next::wire::Box<
225 'static,
226 crate::wire::CqhciInitializeCommandQueueingResponse,
227 >,
228 >,
229 _: (),
230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
231 if let Some(inner) = this {
232 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
233 ::fidl_next::wire::Box::encode_present(out);
234 } else {
235 ::fidl_next::wire::Box::encode_absent(out);
236 }
237
238 Ok(())
239 }
240 }
241
242 impl ::fidl_next::FromWire<crate::wire::CqhciInitializeCommandQueueingResponse>
243 for CqhciInitializeCommandQueueingResponse
244 {
245 #[inline]
246 fn from_wire(wire: crate::wire::CqhciInitializeCommandQueueingResponse) -> Self {
247 Self {
248 cqhci_mmio: ::fidl_next::FromWire::from_wire(wire.cqhci_mmio),
249
250 cqhci_mmio_offset: ::fidl_next::FromWire::from_wire(wire.cqhci_mmio_offset),
251
252 sdhci_mmio: ::fidl_next::FromWire::from_wire(wire.sdhci_mmio),
253
254 sdhci_mmio_offset: ::fidl_next::FromWire::from_wire(wire.sdhci_mmio_offset),
255
256 bti: ::fidl_next::FromWire::from_wire(wire.bti),
257
258 interrupt: ::fidl_next::FromWire::from_wire(wire.interrupt),
259 }
260 }
261 }
262
263 #[derive(Debug, PartialEq)]
264 #[repr(C)]
265 pub struct SdmmcRegisterInBandInterruptRequest {
266 pub interrupt_cb: ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::DriverChannel>,
267 }
268
269 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcRegisterInBandInterruptRequest, ___E>
270 for SdmmcRegisterInBandInterruptRequest
271 where
272 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
273 ___E: ::fidl_next::fuchsia::HandleEncoder,
274 {
275 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
276 Self,
277 crate::wire::SdmmcRegisterInBandInterruptRequest,
278 > = unsafe {
279 ::fidl_next::CopyOptimization::enable_if(
280 true
281
282 && <
283 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::DriverChannel> as ::fidl_next::Encode<::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>, ___E>
284 >::COPY_OPTIMIZATION.is_enabled()
285
286 )
287 };
288
289 #[inline]
290 fn encode(
291 self,
292 encoder_: &mut ___E,
293 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterInBandInterruptRequest>,
294 _: (),
295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
296 ::fidl_next::munge! {
297 let crate::wire::SdmmcRegisterInBandInterruptRequest {
298 interrupt_cb,
299
300 } = out_;
301 }
302
303 ::fidl_next::Encode::encode(self.interrupt_cb, encoder_, interrupt_cb, ())?;
304
305 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(interrupt_cb.as_mut_ptr()) };
306
307 Ok(())
308 }
309 }
310
311 unsafe impl<___E>
312 ::fidl_next::EncodeOption<
313 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRegisterInBandInterruptRequest>,
314 ___E,
315 > for SdmmcRegisterInBandInterruptRequest
316 where
317 ___E: ::fidl_next::Encoder + ?Sized,
318 SdmmcRegisterInBandInterruptRequest:
319 ::fidl_next::Encode<crate::wire::SdmmcRegisterInBandInterruptRequest, ___E>,
320 {
321 #[inline]
322 fn encode_option(
323 this: ::core::option::Option<Self>,
324 encoder: &mut ___E,
325 out: &mut ::core::mem::MaybeUninit<
326 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRegisterInBandInterruptRequest>,
327 >,
328 _: (),
329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
330 if let Some(inner) = this {
331 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
332 ::fidl_next::wire::Box::encode_present(out);
333 } else {
334 ::fidl_next::wire::Box::encode_absent(out);
335 }
336
337 Ok(())
338 }
339 }
340
341 impl ::fidl_next::FromWire<crate::wire::SdmmcRegisterInBandInterruptRequest>
342 for SdmmcRegisterInBandInterruptRequest
343 {
344 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
345 crate::wire::SdmmcRegisterInBandInterruptRequest,
346 Self,
347 > = unsafe {
348 ::fidl_next::CopyOptimization::enable_if(
349 true
350
351 && <
352 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::DriverChannel> as ::fidl_next::FromWire<::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>>
353 >::COPY_OPTIMIZATION.is_enabled()
354
355 )
356 };
357
358 #[inline]
359 fn from_wire(wire: crate::wire::SdmmcRegisterInBandInterruptRequest) -> Self {
360 Self { interrupt_cb: ::fidl_next::FromWire::from_wire(wire.interrupt_cb) }
361 }
362 }
363
364 #[derive(Debug, PartialEq)]
365 pub struct SdmmcRegisterVmoRequest {
366 pub vmo_id: u32,
367
368 pub client_id: u8,
369
370 pub vmo: ::fidl_next::fuchsia::zx::Vmo,
371
372 pub offset: u64,
373
374 pub size: u64,
375
376 pub vmo_rights: crate::natural::SdmmcVmoRight,
377 }
378
379 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcRegisterVmoRequest, ___E>
380 for SdmmcRegisterVmoRequest
381 where
382 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
383 ___E: ::fidl_next::fuchsia::HandleEncoder,
384 {
385 #[inline]
386 fn encode(
387 self,
388 encoder_: &mut ___E,
389 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterVmoRequest>,
390 _: (),
391 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
392 ::fidl_next::munge! {
393 let crate::wire::SdmmcRegisterVmoRequest {
394 vmo_id,
395 client_id,
396 vmo,
397 offset,
398 size,
399 vmo_rights,
400
401 } = out_;
402 }
403
404 ::fidl_next::Encode::encode(self.vmo_id, encoder_, vmo_id, ())?;
405
406 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo_id.as_mut_ptr()) };
407
408 ::fidl_next::Encode::encode(self.client_id, encoder_, client_id, ())?;
409
410 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_id.as_mut_ptr()) };
411
412 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
413
414 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
415
416 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
417
418 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
419
420 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
421
422 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
423
424 ::fidl_next::Encode::encode(self.vmo_rights, encoder_, vmo_rights, ())?;
425
426 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo_rights.as_mut_ptr()) };
427
428 Ok(())
429 }
430 }
431
432 unsafe impl<___E>
433 ::fidl_next::EncodeOption<
434 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRegisterVmoRequest>,
435 ___E,
436 > for SdmmcRegisterVmoRequest
437 where
438 ___E: ::fidl_next::Encoder + ?Sized,
439 SdmmcRegisterVmoRequest: ::fidl_next::Encode<crate::wire::SdmmcRegisterVmoRequest, ___E>,
440 {
441 #[inline]
442 fn encode_option(
443 this: ::core::option::Option<Self>,
444 encoder: &mut ___E,
445 out: &mut ::core::mem::MaybeUninit<
446 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRegisterVmoRequest>,
447 >,
448 _: (),
449 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
450 if let Some(inner) = this {
451 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
452 ::fidl_next::wire::Box::encode_present(out);
453 } else {
454 ::fidl_next::wire::Box::encode_absent(out);
455 }
456
457 Ok(())
458 }
459 }
460
461 impl ::fidl_next::FromWire<crate::wire::SdmmcRegisterVmoRequest> for SdmmcRegisterVmoRequest {
462 #[inline]
463 fn from_wire(wire: crate::wire::SdmmcRegisterVmoRequest) -> Self {
464 Self {
465 vmo_id: ::fidl_next::FromWire::from_wire(wire.vmo_id),
466
467 client_id: ::fidl_next::FromWire::from_wire(wire.client_id),
468
469 vmo: ::fidl_next::FromWire::from_wire(wire.vmo),
470
471 offset: ::fidl_next::FromWire::from_wire(wire.offset),
472
473 size: ::fidl_next::FromWire::from_wire(wire.size),
474
475 vmo_rights: ::fidl_next::FromWire::from_wire(wire.vmo_rights),
476 }
477 }
478 }
479
480 #[derive(Debug, PartialEq)]
481 #[repr(C)]
482 pub struct SdmmcUnregisterVmoResponse {
483 pub vmo: ::fidl_next::fuchsia::zx::Vmo,
484 }
485
486 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcUnregisterVmoResponse, ___E>
487 for SdmmcUnregisterVmoResponse
488 where
489 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
490 ___E: ::fidl_next::fuchsia::HandleEncoder,
491 {
492 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
493 Self,
494 crate::wire::SdmmcUnregisterVmoResponse,
495 > = unsafe {
496 ::fidl_next::CopyOptimization::enable_if(
497 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<
498 ::fidl_next::wire::fuchsia::Vmo,
499 ___E,
500 >>::COPY_OPTIMIZATION
501 .is_enabled(),
502 )
503 };
504
505 #[inline]
506 fn encode(
507 self,
508 encoder_: &mut ___E,
509 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcUnregisterVmoResponse>,
510 _: (),
511 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
512 ::fidl_next::munge! {
513 let crate::wire::SdmmcUnregisterVmoResponse {
514 vmo,
515
516 } = out_;
517 }
518
519 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
520
521 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
522
523 Ok(())
524 }
525 }
526
527 unsafe impl<___E>
528 ::fidl_next::EncodeOption<
529 ::fidl_next::wire::Box<'static, crate::wire::SdmmcUnregisterVmoResponse>,
530 ___E,
531 > for SdmmcUnregisterVmoResponse
532 where
533 ___E: ::fidl_next::Encoder + ?Sized,
534 SdmmcUnregisterVmoResponse:
535 ::fidl_next::Encode<crate::wire::SdmmcUnregisterVmoResponse, ___E>,
536 {
537 #[inline]
538 fn encode_option(
539 this: ::core::option::Option<Self>,
540 encoder: &mut ___E,
541 out: &mut ::core::mem::MaybeUninit<
542 ::fidl_next::wire::Box<'static, crate::wire::SdmmcUnregisterVmoResponse>,
543 >,
544 _: (),
545 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
546 if let Some(inner) = this {
547 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
548 ::fidl_next::wire::Box::encode_present(out);
549 } else {
550 ::fidl_next::wire::Box::encode_absent(out);
551 }
552
553 Ok(())
554 }
555 }
556
557 impl ::fidl_next::FromWire<crate::wire::SdmmcUnregisterVmoResponse> for SdmmcUnregisterVmoResponse {
558 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
559 crate::wire::SdmmcUnregisterVmoResponse,
560 Self,
561 > = unsafe {
562 ::fidl_next::CopyOptimization::enable_if(
563 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
564 ::fidl_next::wire::fuchsia::Vmo,
565 >>::COPY_OPTIMIZATION
566 .is_enabled(),
567 )
568 };
569
570 #[inline]
571 fn from_wire(wire: crate::wire::SdmmcUnregisterVmoResponse) -> Self {
572 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
573 }
574 }
575
576 #[derive(Debug, PartialEq)]
577 pub enum SdmmcBuffer {
578 VmoId(u32),
579
580 Vmo(::fidl_next::fuchsia::zx::Vmo),
581 }
582
583 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcBuffer, ___E> for SdmmcBuffer
584 where
585 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
586 ___E: ::fidl_next::fuchsia::HandleEncoder,
587 {
588 #[inline]
589 fn encode(
590 self,
591 encoder: &mut ___E,
592 out: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcBuffer>,
593 _: (),
594 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
595 ::fidl_next::munge!(let crate::wire::SdmmcBuffer { raw, _phantom: _ } = out);
596
597 match self {
598 Self::VmoId(value) => ::fidl_next::wire::Union::encode_as_static::<
599 ___E,
600 ::fidl_next::wire::Uint32,
601 >(value, 1, encoder, raw, ())?,
602
603 Self::Vmo(value) => ::fidl_next::wire::Union::encode_as_static::<
604 ___E,
605 ::fidl_next::wire::fuchsia::Vmo,
606 >(value, 2, encoder, raw, ())?,
607 }
608
609 Ok(())
610 }
611 }
612
613 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::SdmmcBuffer, ___E> for SdmmcBuffer
614 where
615 ___E: ?Sized,
616 SdmmcBuffer: ::fidl_next::Encode<crate::wire::SdmmcBuffer, ___E>,
617 {
618 #[inline]
619 fn encode_option(
620 this: ::core::option::Option<Self>,
621 encoder: &mut ___E,
622 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SdmmcBuffer>,
623 _: (),
624 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
625 ::fidl_next::munge!(let crate::wire_optional::SdmmcBuffer { raw, _phantom: _ } = &mut *out);
626
627 if let Some(inner) = this {
628 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
629 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
630 } else {
631 ::fidl_next::wire::Union::encode_absent(raw);
632 }
633
634 Ok(())
635 }
636 }
637
638 impl ::fidl_next::FromWire<crate::wire::SdmmcBuffer> for SdmmcBuffer {
639 #[inline]
640 fn from_wire(wire: crate::wire::SdmmcBuffer) -> Self {
641 let wire = ::core::mem::ManuallyDrop::new(wire);
642 match wire.raw.ordinal() {
643 1 => Self::VmoId(::fidl_next::FromWire::from_wire(unsafe {
644 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
645 })),
646
647 2 => Self::Vmo(::fidl_next::FromWire::from_wire(unsafe {
648 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
649 })),
650
651 _ => unsafe { ::core::hint::unreachable_unchecked() },
652 }
653 }
654 }
655
656 impl ::fidl_next::FromWireOption<crate::wire_optional::SdmmcBuffer> for SdmmcBuffer {
657 #[inline]
658 fn from_wire_option(
659 wire: crate::wire_optional::SdmmcBuffer,
660 ) -> ::core::option::Option<Self> {
661 if let Some(inner) = wire.into_option() {
662 Some(::fidl_next::FromWire::from_wire(inner))
663 } else {
664 None
665 }
666 }
667 }
668
669 impl ::fidl_next::FromWireOption<crate::wire_optional::SdmmcBuffer> for Box<SdmmcBuffer> {
670 #[inline]
671 fn from_wire_option(
672 wire: crate::wire_optional::SdmmcBuffer,
673 ) -> ::core::option::Option<Self> {
674 <
675 SdmmcBuffer as ::fidl_next::FromWireOption<crate::wire_optional::SdmmcBuffer>
676 >::from_wire_option(wire).map(Box::new)
677 }
678 }
679
680 #[derive(Debug, PartialEq)]
681 #[repr(C)]
682 pub struct SdmmcBufferRegion {
683 pub buffer: crate::natural::SdmmcBuffer,
684
685 pub offset: u64,
686
687 pub size: u64,
688 }
689
690 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcBufferRegion, ___E> for SdmmcBufferRegion
691 where
692 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
693 ___E: ::fidl_next::fuchsia::HandleEncoder,
694 {
695 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
696 Self,
697 crate::wire::SdmmcBufferRegion,
698 > = unsafe {
699 ::fidl_next::CopyOptimization::enable_if(
700 true
701
702 && <
703 crate::natural::SdmmcBuffer as ::fidl_next::Encode<crate::wire::SdmmcBuffer, ___E>
704 >::COPY_OPTIMIZATION.is_enabled()
705
706 && <
707 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
708 >::COPY_OPTIMIZATION.is_enabled()
709
710 && <
711 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
712 >::COPY_OPTIMIZATION.is_enabled()
713
714 )
715 };
716
717 #[inline]
718 fn encode(
719 self,
720 encoder_: &mut ___E,
721 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcBufferRegion>,
722 _: (),
723 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
724 ::fidl_next::munge! {
725 let crate::wire::SdmmcBufferRegion {
726 buffer,
727 offset,
728 size,
729
730 } = out_;
731 }
732
733 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, ())?;
734
735 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffer.as_mut_ptr()) };
736
737 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
738
739 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
740
741 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
742
743 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
744
745 Ok(())
746 }
747 }
748
749 unsafe impl<___E>
750 ::fidl_next::EncodeOption<
751 ::fidl_next::wire::Box<'static, crate::wire::SdmmcBufferRegion>,
752 ___E,
753 > for SdmmcBufferRegion
754 where
755 ___E: ::fidl_next::Encoder + ?Sized,
756 SdmmcBufferRegion: ::fidl_next::Encode<crate::wire::SdmmcBufferRegion, ___E>,
757 {
758 #[inline]
759 fn encode_option(
760 this: ::core::option::Option<Self>,
761 encoder: &mut ___E,
762 out: &mut ::core::mem::MaybeUninit<
763 ::fidl_next::wire::Box<'static, crate::wire::SdmmcBufferRegion>,
764 >,
765 _: (),
766 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
767 if let Some(inner) = this {
768 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
769 ::fidl_next::wire::Box::encode_present(out);
770 } else {
771 ::fidl_next::wire::Box::encode_absent(out);
772 }
773
774 Ok(())
775 }
776 }
777
778 impl ::fidl_next::FromWire<crate::wire::SdmmcBufferRegion> for SdmmcBufferRegion {
779 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
780 crate::wire::SdmmcBufferRegion,
781 Self,
782 > = unsafe {
783 ::fidl_next::CopyOptimization::enable_if(
784 true && <crate::natural::SdmmcBuffer as ::fidl_next::FromWire<
785 crate::wire::SdmmcBuffer,
786 >>::COPY_OPTIMIZATION
787 .is_enabled()
788 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
789 .is_enabled()
790 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
791 .is_enabled(),
792 )
793 };
794
795 #[inline]
796 fn from_wire(wire: crate::wire::SdmmcBufferRegion) -> Self {
797 Self {
798 buffer: ::fidl_next::FromWire::from_wire(wire.buffer),
799
800 offset: ::fidl_next::FromWire::from_wire(wire.offset),
801
802 size: ::fidl_next::FromWire::from_wire(wire.size),
803 }
804 }
805 }
806
807 #[derive(Debug, PartialEq)]
808 pub struct SdmmcReq {
809 pub cmd_idx: u32,
810
811 pub cmd_flags: u32,
812
813 pub arg: u32,
814
815 pub blocksize: u32,
816
817 pub suppress_error_messages: bool,
818
819 pub client_id: u8,
820
821 pub use_inline_crypto: bool,
822
823 pub slot: u8,
824
825 pub dun: u32,
826
827 pub buffers: ::std::vec::Vec<crate::natural::SdmmcBufferRegion>,
828 }
829
830 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcReq<'static>, ___E> for SdmmcReq
831 where
832 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
833 ___E: ::fidl_next::Encoder,
834 ___E: ::fidl_next::fuchsia::HandleEncoder,
835 {
836 #[inline]
837 fn encode(
838 self,
839 encoder_: &mut ___E,
840 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcReq<'static>>,
841 _: (),
842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
843 ::fidl_next::munge! {
844 let crate::wire::SdmmcReq {
845 cmd_idx,
846 cmd_flags,
847 arg,
848 blocksize,
849 suppress_error_messages,
850 client_id,
851 use_inline_crypto,
852 slot,
853 dun,
854 buffers,
855
856 } = out_;
857 }
858
859 ::fidl_next::Encode::encode(self.cmd_idx, encoder_, cmd_idx, ())?;
860
861 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(cmd_idx.as_mut_ptr()) };
862
863 ::fidl_next::Encode::encode(self.cmd_flags, encoder_, cmd_flags, ())?;
864
865 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(cmd_flags.as_mut_ptr()) };
866
867 ::fidl_next::Encode::encode(self.arg, encoder_, arg, ())?;
868
869 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(arg.as_mut_ptr()) };
870
871 ::fidl_next::Encode::encode(self.blocksize, encoder_, blocksize, ())?;
872
873 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(blocksize.as_mut_ptr()) };
874
875 ::fidl_next::Encode::encode(
876 self.suppress_error_messages,
877 encoder_,
878 suppress_error_messages,
879 (),
880 )?;
881
882 let mut _field =
883 unsafe { ::fidl_next::Slot::new_unchecked(suppress_error_messages.as_mut_ptr()) };
884
885 ::fidl_next::Encode::encode(self.client_id, encoder_, client_id, ())?;
886
887 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_id.as_mut_ptr()) };
888
889 ::fidl_next::Encode::encode(self.use_inline_crypto, encoder_, use_inline_crypto, ())?;
890
891 let mut _field =
892 unsafe { ::fidl_next::Slot::new_unchecked(use_inline_crypto.as_mut_ptr()) };
893
894 ::fidl_next::Encode::encode(self.slot, encoder_, slot, ())?;
895
896 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(slot.as_mut_ptr()) };
897
898 ::fidl_next::Encode::encode(self.dun, encoder_, dun, ())?;
899
900 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dun.as_mut_ptr()) };
901
902 ::fidl_next::Encode::encode(self.buffers, encoder_, buffers, (4294967295, ()))?;
903
904 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(buffers.as_mut_ptr()) };
905 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
906
907 Ok(())
908 }
909 }
910
911 unsafe impl<___E>
912 ::fidl_next::EncodeOption<
913 ::fidl_next::wire::Box<'static, crate::wire::SdmmcReq<'static>>,
914 ___E,
915 > for SdmmcReq
916 where
917 ___E: ::fidl_next::Encoder + ?Sized,
918 SdmmcReq: ::fidl_next::Encode<crate::wire::SdmmcReq<'static>, ___E>,
919 {
920 #[inline]
921 fn encode_option(
922 this: ::core::option::Option<Self>,
923 encoder: &mut ___E,
924 out: &mut ::core::mem::MaybeUninit<
925 ::fidl_next::wire::Box<'static, crate::wire::SdmmcReq<'static>>,
926 >,
927 _: (),
928 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
929 if let Some(inner) = this {
930 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
931 ::fidl_next::wire::Box::encode_present(out);
932 } else {
933 ::fidl_next::wire::Box::encode_absent(out);
934 }
935
936 Ok(())
937 }
938 }
939
940 impl<'de> ::fidl_next::FromWire<crate::wire::SdmmcReq<'de>> for SdmmcReq {
941 #[inline]
942 fn from_wire(wire: crate::wire::SdmmcReq<'de>) -> Self {
943 Self {
944 cmd_idx: ::fidl_next::FromWire::from_wire(wire.cmd_idx),
945
946 cmd_flags: ::fidl_next::FromWire::from_wire(wire.cmd_flags),
947
948 arg: ::fidl_next::FromWire::from_wire(wire.arg),
949
950 blocksize: ::fidl_next::FromWire::from_wire(wire.blocksize),
951
952 suppress_error_messages: ::fidl_next::FromWire::from_wire(
953 wire.suppress_error_messages,
954 ),
955
956 client_id: ::fidl_next::FromWire::from_wire(wire.client_id),
957
958 use_inline_crypto: ::fidl_next::FromWire::from_wire(wire.use_inline_crypto),
959
960 slot: ::fidl_next::FromWire::from_wire(wire.slot),
961
962 dun: ::fidl_next::FromWire::from_wire(wire.dun),
963
964 buffers: ::fidl_next::FromWire::from_wire(wire.buffers),
965 }
966 }
967 }
968
969 #[derive(Debug, PartialEq)]
970 pub struct SdmmcRequestRequest {
971 pub reqs: ::std::vec::Vec<crate::natural::SdmmcReq>,
972 }
973
974 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SdmmcRequestRequest<'static>, ___E>
975 for SdmmcRequestRequest
976 where
977 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
978 ___E: ::fidl_next::Encoder,
979 ___E: ::fidl_next::fuchsia::HandleEncoder,
980 {
981 #[inline]
982 fn encode(
983 self,
984 encoder_: &mut ___E,
985 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRequestRequest<'static>>,
986 _: (),
987 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
988 ::fidl_next::munge! {
989 let crate::wire::SdmmcRequestRequest {
990 reqs,
991
992 } = out_;
993 }
994
995 ::fidl_next::Encode::encode(self.reqs, encoder_, reqs, (4294967295, ()))?;
996
997 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(reqs.as_mut_ptr()) };
998 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
999
1000 Ok(())
1001 }
1002 }
1003
1004 unsafe impl<___E>
1005 ::fidl_next::EncodeOption<
1006 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRequestRequest<'static>>,
1007 ___E,
1008 > for SdmmcRequestRequest
1009 where
1010 ___E: ::fidl_next::Encoder + ?Sized,
1011 SdmmcRequestRequest: ::fidl_next::Encode<crate::wire::SdmmcRequestRequest<'static>, ___E>,
1012 {
1013 #[inline]
1014 fn encode_option(
1015 this: ::core::option::Option<Self>,
1016 encoder: &mut ___E,
1017 out: &mut ::core::mem::MaybeUninit<
1018 ::fidl_next::wire::Box<'static, crate::wire::SdmmcRequestRequest<'static>>,
1019 >,
1020 _: (),
1021 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1022 if let Some(inner) = this {
1023 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1024 ::fidl_next::wire::Box::encode_present(out);
1025 } else {
1026 ::fidl_next::wire::Box::encode_absent(out);
1027 }
1028
1029 Ok(())
1030 }
1031 }
1032
1033 impl<'de> ::fidl_next::FromWire<crate::wire::SdmmcRequestRequest<'de>> for SdmmcRequestRequest {
1034 #[inline]
1035 fn from_wire(wire: crate::wire::SdmmcRequestRequest<'de>) -> Self {
1036 Self { reqs: ::fidl_next::FromWire::from_wire(wire.reqs) }
1037 }
1038 }
1039}
1040
1041pub mod wire {
1042
1043 pub use fidl_next_common_fuchsia_hardware_sdmmc::wire::*;
1044
1045 #[derive(Debug)]
1047 #[repr(C)]
1048 pub struct CqhciInitializeCommandQueueingRequest {
1049 pub virtual_interrupt: ::fidl_next::wire::fuchsia::Interrupt,
1050
1051 pub virtual_interrupt_lifeline: ::fidl_next::wire::fuchsia::EventPair,
1052 }
1053
1054 static_assertions::const_assert_eq!(
1055 std::mem::size_of::<CqhciInitializeCommandQueueingRequest>(),
1056 8
1057 );
1058 static_assertions::const_assert_eq!(
1059 std::mem::align_of::<CqhciInitializeCommandQueueingRequest>(),
1060 4
1061 );
1062
1063 static_assertions::const_assert_eq!(
1064 std::mem::offset_of!(CqhciInitializeCommandQueueingRequest, virtual_interrupt),
1065 0
1066 );
1067
1068 static_assertions::const_assert_eq!(
1069 std::mem::offset_of!(CqhciInitializeCommandQueueingRequest, virtual_interrupt_lifeline),
1070 4
1071 );
1072
1073 impl ::fidl_next::Constrained for CqhciInitializeCommandQueueingRequest {
1074 type Constraint = ();
1075
1076 fn validate(
1077 _: ::fidl_next::Slot<'_, Self>,
1078 _: Self::Constraint,
1079 ) -> Result<(), ::fidl_next::ValidationError> {
1080 Ok(())
1081 }
1082 }
1083
1084 unsafe impl ::fidl_next::Wire for CqhciInitializeCommandQueueingRequest {
1085 type Narrowed<'de> = CqhciInitializeCommandQueueingRequest;
1086
1087 #[inline]
1088 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1089 ::fidl_next::munge! {
1090 let Self {
1091 virtual_interrupt,
1092 virtual_interrupt_lifeline,
1093
1094 } = &mut *out_;
1095 }
1096
1097 ::fidl_next::Wire::zero_padding(virtual_interrupt);
1098
1099 ::fidl_next::Wire::zero_padding(virtual_interrupt_lifeline);
1100 }
1101 }
1102
1103 unsafe impl<___D> ::fidl_next::Decode<___D> for CqhciInitializeCommandQueueingRequest
1104 where
1105 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1106 ___D: ::fidl_next::fuchsia::HandleDecoder,
1107 {
1108 fn decode(
1109 slot_: ::fidl_next::Slot<'_, Self>,
1110 decoder_: &mut ___D,
1111 _: (),
1112 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1113 ::fidl_next::munge! {
1114 let Self {
1115 mut virtual_interrupt,
1116 mut virtual_interrupt_lifeline,
1117
1118 } = slot_;
1119 }
1120
1121 let _field = virtual_interrupt.as_mut();
1122
1123 ::fidl_next::Decode::decode(virtual_interrupt.as_mut(), decoder_, ())?;
1124
1125 let _field = virtual_interrupt_lifeline.as_mut();
1126
1127 ::fidl_next::Decode::decode(virtual_interrupt_lifeline.as_mut(), decoder_, ())?;
1128
1129 Ok(())
1130 }
1131 }
1132
1133 impl ::fidl_next::IntoNatural for CqhciInitializeCommandQueueingRequest {
1134 type Natural = crate::natural::CqhciInitializeCommandQueueingRequest;
1135 }
1136
1137 #[derive(Debug)]
1139 #[repr(C)]
1140 pub struct CqhciInitializeCommandQueueingResponse {
1141 pub cqhci_mmio: ::fidl_next::wire::fuchsia::Vmo,
1142
1143 pub cqhci_mmio_offset: ::fidl_next::wire::Uint64,
1144
1145 pub sdhci_mmio: ::fidl_next::wire::fuchsia::Vmo,
1146
1147 pub sdhci_mmio_offset: ::fidl_next::wire::Uint64,
1148
1149 pub bti: ::fidl_next::wire::fuchsia::Bti,
1150
1151 pub interrupt: ::fidl_next::wire::fuchsia::Interrupt,
1152 }
1153
1154 static_assertions::const_assert_eq!(
1155 std::mem::size_of::<CqhciInitializeCommandQueueingResponse>(),
1156 40
1157 );
1158 static_assertions::const_assert_eq!(
1159 std::mem::align_of::<CqhciInitializeCommandQueueingResponse>(),
1160 8
1161 );
1162
1163 static_assertions::const_assert_eq!(
1164 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, cqhci_mmio),
1165 0
1166 );
1167
1168 static_assertions::const_assert_eq!(
1169 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, cqhci_mmio_offset),
1170 8
1171 );
1172
1173 static_assertions::const_assert_eq!(
1174 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, sdhci_mmio),
1175 16
1176 );
1177
1178 static_assertions::const_assert_eq!(
1179 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, sdhci_mmio_offset),
1180 24
1181 );
1182
1183 static_assertions::const_assert_eq!(
1184 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, bti),
1185 32
1186 );
1187
1188 static_assertions::const_assert_eq!(
1189 std::mem::offset_of!(CqhciInitializeCommandQueueingResponse, interrupt),
1190 36
1191 );
1192
1193 impl ::fidl_next::Constrained for CqhciInitializeCommandQueueingResponse {
1194 type Constraint = ();
1195
1196 fn validate(
1197 _: ::fidl_next::Slot<'_, Self>,
1198 _: Self::Constraint,
1199 ) -> Result<(), ::fidl_next::ValidationError> {
1200 Ok(())
1201 }
1202 }
1203
1204 unsafe impl ::fidl_next::Wire for CqhciInitializeCommandQueueingResponse {
1205 type Narrowed<'de> = CqhciInitializeCommandQueueingResponse;
1206
1207 #[inline]
1208 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1209 ::fidl_next::munge! {
1210 let Self {
1211 cqhci_mmio,
1212 cqhci_mmio_offset,
1213 sdhci_mmio,
1214 sdhci_mmio_offset,
1215 bti,
1216 interrupt,
1217
1218 } = &mut *out_;
1219 }
1220
1221 ::fidl_next::Wire::zero_padding(cqhci_mmio);
1222
1223 ::fidl_next::Wire::zero_padding(cqhci_mmio_offset);
1224
1225 ::fidl_next::Wire::zero_padding(sdhci_mmio);
1226
1227 ::fidl_next::Wire::zero_padding(sdhci_mmio_offset);
1228
1229 ::fidl_next::Wire::zero_padding(bti);
1230
1231 ::fidl_next::Wire::zero_padding(interrupt);
1232
1233 unsafe {
1234 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
1235 }
1236
1237 unsafe {
1238 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
1239 }
1240 }
1241 }
1242
1243 unsafe impl<___D> ::fidl_next::Decode<___D> for CqhciInitializeCommandQueueingResponse
1244 where
1245 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1246 ___D: ::fidl_next::fuchsia::HandleDecoder,
1247 {
1248 fn decode(
1249 slot_: ::fidl_next::Slot<'_, Self>,
1250 decoder_: &mut ___D,
1251 _: (),
1252 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1253 if slot_.as_bytes()[20..24] != [0u8; 4] {
1254 return Err(::fidl_next::DecodeError::InvalidPadding);
1255 }
1256
1257 if slot_.as_bytes()[4..8] != [0u8; 4] {
1258 return Err(::fidl_next::DecodeError::InvalidPadding);
1259 }
1260
1261 ::fidl_next::munge! {
1262 let Self {
1263 mut cqhci_mmio,
1264 mut cqhci_mmio_offset,
1265 mut sdhci_mmio,
1266 mut sdhci_mmio_offset,
1267 mut bti,
1268 mut interrupt,
1269
1270 } = slot_;
1271 }
1272
1273 let _field = cqhci_mmio.as_mut();
1274
1275 ::fidl_next::Decode::decode(cqhci_mmio.as_mut(), decoder_, ())?;
1276
1277 let _field = cqhci_mmio_offset.as_mut();
1278
1279 ::fidl_next::Decode::decode(cqhci_mmio_offset.as_mut(), decoder_, ())?;
1280
1281 let _field = sdhci_mmio.as_mut();
1282
1283 ::fidl_next::Decode::decode(sdhci_mmio.as_mut(), decoder_, ())?;
1284
1285 let _field = sdhci_mmio_offset.as_mut();
1286
1287 ::fidl_next::Decode::decode(sdhci_mmio_offset.as_mut(), decoder_, ())?;
1288
1289 let _field = bti.as_mut();
1290
1291 ::fidl_next::Decode::decode(bti.as_mut(), decoder_, ())?;
1292
1293 let _field = interrupt.as_mut();
1294
1295 ::fidl_next::Decode::decode(interrupt.as_mut(), decoder_, ())?;
1296
1297 Ok(())
1298 }
1299 }
1300
1301 impl ::fidl_next::IntoNatural for CqhciInitializeCommandQueueingResponse {
1302 type Natural = crate::natural::CqhciInitializeCommandQueueingResponse;
1303 }
1304
1305 #[derive(Debug)]
1307 #[repr(C)]
1308 pub struct SdmmcRegisterInBandInterruptRequest {
1309 pub interrupt_cb:
1310 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>,
1311 }
1312
1313 static_assertions::const_assert_eq!(
1314 std::mem::size_of::<SdmmcRegisterInBandInterruptRequest>(),
1315 4
1316 );
1317 static_assertions::const_assert_eq!(
1318 std::mem::align_of::<SdmmcRegisterInBandInterruptRequest>(),
1319 4
1320 );
1321
1322 static_assertions::const_assert_eq!(
1323 std::mem::offset_of!(SdmmcRegisterInBandInterruptRequest, interrupt_cb),
1324 0
1325 );
1326
1327 impl ::fidl_next::Constrained for SdmmcRegisterInBandInterruptRequest {
1328 type Constraint = ();
1329
1330 fn validate(
1331 _: ::fidl_next::Slot<'_, Self>,
1332 _: Self::Constraint,
1333 ) -> Result<(), ::fidl_next::ValidationError> {
1334 Ok(())
1335 }
1336 }
1337
1338 unsafe impl ::fidl_next::Wire for SdmmcRegisterInBandInterruptRequest {
1339 type Narrowed<'de> = SdmmcRegisterInBandInterruptRequest;
1340
1341 #[inline]
1342 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1343 ::fidl_next::munge! {
1344 let Self {
1345 interrupt_cb,
1346
1347 } = &mut *out_;
1348 }
1349
1350 ::fidl_next::Wire::zero_padding(interrupt_cb);
1351 }
1352 }
1353
1354 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcRegisterInBandInterruptRequest
1355 where
1356 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1357 ___D: ::fidl_next::fuchsia::HandleDecoder,
1358 {
1359 fn decode(
1360 slot_: ::fidl_next::Slot<'_, Self>,
1361 decoder_: &mut ___D,
1362 _: (),
1363 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1364 ::fidl_next::munge! {
1365 let Self {
1366 mut interrupt_cb,
1367
1368 } = slot_;
1369 }
1370
1371 let _field = interrupt_cb.as_mut();
1372
1373 ::fidl_next::Decode::decode(interrupt_cb.as_mut(), decoder_, ())?;
1374
1375 Ok(())
1376 }
1377 }
1378
1379 impl ::fidl_next::IntoNatural for SdmmcRegisterInBandInterruptRequest {
1380 type Natural = crate::natural::SdmmcRegisterInBandInterruptRequest;
1381 }
1382
1383 #[derive(Debug)]
1385 #[repr(C)]
1386 pub struct SdmmcRegisterVmoRequest {
1387 pub vmo_id: ::fidl_next::wire::Uint32,
1388
1389 pub client_id: u8,
1390
1391 pub vmo: ::fidl_next::wire::fuchsia::Vmo,
1392
1393 pub offset: ::fidl_next::wire::Uint64,
1394
1395 pub size: ::fidl_next::wire::Uint64,
1396
1397 pub vmo_rights: crate::wire::SdmmcVmoRight,
1398 }
1399
1400 static_assertions::const_assert_eq!(std::mem::size_of::<SdmmcRegisterVmoRequest>(), 40);
1401 static_assertions::const_assert_eq!(std::mem::align_of::<SdmmcRegisterVmoRequest>(), 8);
1402
1403 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcRegisterVmoRequest, vmo_id), 0);
1404
1405 static_assertions::const_assert_eq!(
1406 std::mem::offset_of!(SdmmcRegisterVmoRequest, client_id),
1407 4
1408 );
1409
1410 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcRegisterVmoRequest, vmo), 8);
1411
1412 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcRegisterVmoRequest, offset), 16);
1413
1414 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcRegisterVmoRequest, size), 24);
1415
1416 static_assertions::const_assert_eq!(
1417 std::mem::offset_of!(SdmmcRegisterVmoRequest, vmo_rights),
1418 32
1419 );
1420
1421 impl ::fidl_next::Constrained for SdmmcRegisterVmoRequest {
1422 type Constraint = ();
1423
1424 fn validate(
1425 _: ::fidl_next::Slot<'_, Self>,
1426 _: Self::Constraint,
1427 ) -> Result<(), ::fidl_next::ValidationError> {
1428 Ok(())
1429 }
1430 }
1431
1432 unsafe impl ::fidl_next::Wire for SdmmcRegisterVmoRequest {
1433 type Narrowed<'de> = SdmmcRegisterVmoRequest;
1434
1435 #[inline]
1436 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1437 ::fidl_next::munge! {
1438 let Self {
1439 vmo_id,
1440 client_id,
1441 vmo,
1442 offset,
1443 size,
1444 vmo_rights,
1445
1446 } = &mut *out_;
1447 }
1448
1449 ::fidl_next::Wire::zero_padding(vmo_id);
1450
1451 ::fidl_next::Wire::zero_padding(client_id);
1452
1453 ::fidl_next::Wire::zero_padding(vmo);
1454
1455 ::fidl_next::Wire::zero_padding(offset);
1456
1457 ::fidl_next::Wire::zero_padding(size);
1458
1459 ::fidl_next::Wire::zero_padding(vmo_rights);
1460
1461 unsafe {
1462 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
1463 }
1464
1465 unsafe {
1466 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
1467 }
1468
1469 unsafe {
1470 out_.as_mut_ptr().cast::<u8>().add(5).write_bytes(0, 3);
1471 }
1472 }
1473 }
1474
1475 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcRegisterVmoRequest
1476 where
1477 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1478 ___D: ::fidl_next::fuchsia::HandleDecoder,
1479 {
1480 fn decode(
1481 slot_: ::fidl_next::Slot<'_, Self>,
1482 decoder_: &mut ___D,
1483 _: (),
1484 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1485 if slot_.as_bytes()[36..40] != [0u8; 4] {
1486 return Err(::fidl_next::DecodeError::InvalidPadding);
1487 }
1488
1489 if slot_.as_bytes()[12..16] != [0u8; 4] {
1490 return Err(::fidl_next::DecodeError::InvalidPadding);
1491 }
1492
1493 if slot_.as_bytes()[5..8] != [0u8; 3] {
1494 return Err(::fidl_next::DecodeError::InvalidPadding);
1495 }
1496
1497 ::fidl_next::munge! {
1498 let Self {
1499 mut vmo_id,
1500 mut client_id,
1501 mut vmo,
1502 mut offset,
1503 mut size,
1504 mut vmo_rights,
1505
1506 } = slot_;
1507 }
1508
1509 let _field = vmo_id.as_mut();
1510
1511 ::fidl_next::Decode::decode(vmo_id.as_mut(), decoder_, ())?;
1512
1513 let _field = client_id.as_mut();
1514
1515 ::fidl_next::Decode::decode(client_id.as_mut(), decoder_, ())?;
1516
1517 let _field = vmo.as_mut();
1518
1519 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
1520
1521 let _field = offset.as_mut();
1522
1523 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
1524
1525 let _field = size.as_mut();
1526
1527 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
1528
1529 let _field = vmo_rights.as_mut();
1530
1531 ::fidl_next::Decode::decode(vmo_rights.as_mut(), decoder_, ())?;
1532
1533 Ok(())
1534 }
1535 }
1536
1537 impl ::fidl_next::IntoNatural for SdmmcRegisterVmoRequest {
1538 type Natural = crate::natural::SdmmcRegisterVmoRequest;
1539 }
1540
1541 #[derive(Debug)]
1543 #[repr(C)]
1544 pub struct SdmmcUnregisterVmoResponse {
1545 pub vmo: ::fidl_next::wire::fuchsia::Vmo,
1546 }
1547
1548 static_assertions::const_assert_eq!(std::mem::size_of::<SdmmcUnregisterVmoResponse>(), 4);
1549 static_assertions::const_assert_eq!(std::mem::align_of::<SdmmcUnregisterVmoResponse>(), 4);
1550
1551 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcUnregisterVmoResponse, vmo), 0);
1552
1553 impl ::fidl_next::Constrained for SdmmcUnregisterVmoResponse {
1554 type Constraint = ();
1555
1556 fn validate(
1557 _: ::fidl_next::Slot<'_, Self>,
1558 _: Self::Constraint,
1559 ) -> Result<(), ::fidl_next::ValidationError> {
1560 Ok(())
1561 }
1562 }
1563
1564 unsafe impl ::fidl_next::Wire for SdmmcUnregisterVmoResponse {
1565 type Narrowed<'de> = SdmmcUnregisterVmoResponse;
1566
1567 #[inline]
1568 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1569 ::fidl_next::munge! {
1570 let Self {
1571 vmo,
1572
1573 } = &mut *out_;
1574 }
1575
1576 ::fidl_next::Wire::zero_padding(vmo);
1577 }
1578 }
1579
1580 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcUnregisterVmoResponse
1581 where
1582 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1583 ___D: ::fidl_next::fuchsia::HandleDecoder,
1584 {
1585 fn decode(
1586 slot_: ::fidl_next::Slot<'_, Self>,
1587 decoder_: &mut ___D,
1588 _: (),
1589 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1590 ::fidl_next::munge! {
1591 let Self {
1592 mut vmo,
1593
1594 } = slot_;
1595 }
1596
1597 let _field = vmo.as_mut();
1598
1599 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
1600
1601 Ok(())
1602 }
1603 }
1604
1605 impl ::fidl_next::IntoNatural for SdmmcUnregisterVmoResponse {
1606 type Natural = crate::natural::SdmmcUnregisterVmoResponse;
1607 }
1608
1609 #[repr(transparent)]
1611 pub struct SdmmcBuffer {
1612 pub(crate) raw: ::fidl_next::wire::Union,
1613 pub(crate) _phantom: ::core::marker::PhantomData<()>,
1614 }
1615
1616 impl Drop for SdmmcBuffer {
1617 fn drop(&mut self) {
1618 match self.raw.ordinal() {
1619 1 => {
1620 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
1621 }
1622
1623 2 => {
1624 let _ = unsafe {
1625 self.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
1626 };
1627 }
1628
1629 _ => unsafe { ::core::hint::unreachable_unchecked() },
1630 }
1631 }
1632 }
1633
1634 impl ::fidl_next::Constrained for SdmmcBuffer {
1635 type Constraint = ();
1636
1637 fn validate(
1638 _: ::fidl_next::Slot<'_, Self>,
1639 _: Self::Constraint,
1640 ) -> Result<(), ::fidl_next::ValidationError> {
1641 Ok(())
1642 }
1643 }
1644
1645 unsafe impl ::fidl_next::Wire for SdmmcBuffer {
1646 type Narrowed<'de> = SdmmcBuffer;
1647
1648 #[inline]
1649 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
1650 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
1651 ::fidl_next::wire::Union::zero_padding(raw);
1652 }
1653 }
1654
1655 pub mod sdmmc_buffer {
1656 pub enum Ref<'de> {
1657 VmoId(&'de ::fidl_next::wire::Uint32),
1658
1659 Vmo(&'de ::fidl_next::wire::fuchsia::Vmo),
1660 }
1661
1662 pub enum Value {
1663 VmoId(::fidl_next::wire::Uint32),
1664
1665 Vmo(::fidl_next::wire::fuchsia::Vmo),
1666 }
1667 }
1668
1669 impl SdmmcBuffer {
1670 pub fn as_ref(&self) -> crate::wire::sdmmc_buffer::Ref<'_> {
1671 match self.raw.ordinal() {
1672 1 => crate::wire::sdmmc_buffer::Ref::VmoId(unsafe {
1673 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
1674 }),
1675
1676 2 => crate::wire::sdmmc_buffer::Ref::Vmo(unsafe {
1677 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
1678 }),
1679
1680 _ => unsafe { ::core::hint::unreachable_unchecked() },
1681 }
1682 }
1683
1684 pub fn into_inner(self) -> crate::wire::sdmmc_buffer::Value {
1685 let this = ::core::mem::ManuallyDrop::new(self);
1686
1687 match this.raw.ordinal() {
1688 1 => crate::wire::sdmmc_buffer::Value::VmoId(unsafe {
1689 this.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
1690 }),
1691
1692 2 => crate::wire::sdmmc_buffer::Value::Vmo(unsafe {
1693 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
1694 }),
1695
1696 _ => unsafe { ::core::hint::unreachable_unchecked() },
1697 }
1698 }
1699 }
1700
1701 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcBuffer
1702 where
1703 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1704 ___D: ::fidl_next::fuchsia::HandleDecoder,
1705 {
1706 fn decode(
1707 mut slot: ::fidl_next::Slot<'_, Self>,
1708 decoder: &mut ___D,
1709 _: (),
1710 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1711 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
1712 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
1713 1 => ::fidl_next::wire::Union::decode_as_static::<___D, ::fidl_next::wire::Uint32>(
1714 raw,
1715 decoder,
1716 (),
1717 )?,
1718
1719 2 => ::fidl_next::wire::Union::decode_as_static::<
1720 ___D,
1721 ::fidl_next::wire::fuchsia::Vmo,
1722 >(raw, decoder, ())?,
1723
1724 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
1725 }
1726
1727 Ok(())
1728 }
1729 }
1730
1731 impl ::core::fmt::Debug for SdmmcBuffer {
1732 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1733 match self.raw.ordinal() {
1734 1 => unsafe {
1735 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
1736 },
1737 2 => unsafe {
1738 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>().fmt(f)
1739 },
1740 _ => unsafe { ::core::hint::unreachable_unchecked() },
1741 }
1742 }
1743 }
1744
1745 impl ::fidl_next::IntoNatural for SdmmcBuffer {
1746 type Natural = crate::natural::SdmmcBuffer;
1747 }
1748
1749 #[derive(Debug)]
1751 #[repr(C)]
1752 pub struct SdmmcBufferRegion {
1753 pub buffer: crate::wire::SdmmcBuffer,
1754
1755 pub offset: ::fidl_next::wire::Uint64,
1756
1757 pub size: ::fidl_next::wire::Uint64,
1758 }
1759
1760 static_assertions::const_assert_eq!(std::mem::size_of::<SdmmcBufferRegion>(), 32);
1761 static_assertions::const_assert_eq!(std::mem::align_of::<SdmmcBufferRegion>(), 8);
1762
1763 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcBufferRegion, buffer), 0);
1764
1765 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcBufferRegion, offset), 16);
1766
1767 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcBufferRegion, size), 24);
1768
1769 impl ::fidl_next::Constrained for SdmmcBufferRegion {
1770 type Constraint = ();
1771
1772 fn validate(
1773 _: ::fidl_next::Slot<'_, Self>,
1774 _: Self::Constraint,
1775 ) -> Result<(), ::fidl_next::ValidationError> {
1776 Ok(())
1777 }
1778 }
1779
1780 unsafe impl ::fidl_next::Wire for SdmmcBufferRegion {
1781 type Narrowed<'de> = SdmmcBufferRegion;
1782
1783 #[inline]
1784 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1785 ::fidl_next::munge! {
1786 let Self {
1787 buffer,
1788 offset,
1789 size,
1790
1791 } = &mut *out_;
1792 }
1793
1794 ::fidl_next::Wire::zero_padding(buffer);
1795
1796 ::fidl_next::Wire::zero_padding(offset);
1797
1798 ::fidl_next::Wire::zero_padding(size);
1799 }
1800 }
1801
1802 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcBufferRegion
1803 where
1804 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1805 ___D: ::fidl_next::fuchsia::HandleDecoder,
1806 {
1807 fn decode(
1808 slot_: ::fidl_next::Slot<'_, Self>,
1809 decoder_: &mut ___D,
1810 _: (),
1811 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1812 ::fidl_next::munge! {
1813 let Self {
1814 mut buffer,
1815 mut offset,
1816 mut size,
1817
1818 } = slot_;
1819 }
1820
1821 let _field = buffer.as_mut();
1822
1823 ::fidl_next::Decode::decode(buffer.as_mut(), decoder_, ())?;
1824
1825 let _field = offset.as_mut();
1826
1827 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
1828
1829 let _field = size.as_mut();
1830
1831 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
1832
1833 Ok(())
1834 }
1835 }
1836
1837 impl ::fidl_next::IntoNatural for SdmmcBufferRegion {
1838 type Natural = crate::natural::SdmmcBufferRegion;
1839 }
1840
1841 #[derive(Debug)]
1843 #[repr(C)]
1844 pub struct SdmmcReq<'de> {
1845 pub cmd_idx: ::fidl_next::wire::Uint32,
1846
1847 pub cmd_flags: ::fidl_next::wire::Uint32,
1848
1849 pub arg: ::fidl_next::wire::Uint32,
1850
1851 pub blocksize: ::fidl_next::wire::Uint32,
1852
1853 pub suppress_error_messages: bool,
1854
1855 pub client_id: u8,
1856
1857 pub use_inline_crypto: bool,
1858
1859 pub slot: u8,
1860
1861 pub dun: ::fidl_next::wire::Uint32,
1862
1863 pub buffers: ::fidl_next::wire::Vector<'de, crate::wire::SdmmcBufferRegion>,
1864 }
1865
1866 static_assertions::const_assert_eq!(std::mem::size_of::<SdmmcReq<'_>>(), 40);
1867 static_assertions::const_assert_eq!(std::mem::align_of::<SdmmcReq<'_>>(), 8);
1868
1869 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, cmd_idx), 0);
1870
1871 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, cmd_flags), 4);
1872
1873 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, arg), 8);
1874
1875 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, blocksize), 12);
1876
1877 static_assertions::const_assert_eq!(
1878 std::mem::offset_of!(SdmmcReq<'_>, suppress_error_messages),
1879 16
1880 );
1881
1882 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, client_id), 17);
1883
1884 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, use_inline_crypto), 18);
1885
1886 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, slot), 19);
1887
1888 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, dun), 20);
1889
1890 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcReq<'_>, buffers), 24);
1891
1892 impl ::fidl_next::Constrained for SdmmcReq<'_> {
1893 type Constraint = ();
1894
1895 fn validate(
1896 _: ::fidl_next::Slot<'_, Self>,
1897 _: Self::Constraint,
1898 ) -> Result<(), ::fidl_next::ValidationError> {
1899 Ok(())
1900 }
1901 }
1902
1903 unsafe impl ::fidl_next::Wire for SdmmcReq<'static> {
1904 type Narrowed<'de> = SdmmcReq<'de>;
1905
1906 #[inline]
1907 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1908 ::fidl_next::munge! {
1909 let Self {
1910 cmd_idx,
1911 cmd_flags,
1912 arg,
1913 blocksize,
1914 suppress_error_messages,
1915 client_id,
1916 use_inline_crypto,
1917 slot,
1918 dun,
1919 buffers,
1920
1921 } = &mut *out_;
1922 }
1923
1924 ::fidl_next::Wire::zero_padding(cmd_idx);
1925
1926 ::fidl_next::Wire::zero_padding(cmd_flags);
1927
1928 ::fidl_next::Wire::zero_padding(arg);
1929
1930 ::fidl_next::Wire::zero_padding(blocksize);
1931
1932 ::fidl_next::Wire::zero_padding(suppress_error_messages);
1933
1934 ::fidl_next::Wire::zero_padding(client_id);
1935
1936 ::fidl_next::Wire::zero_padding(use_inline_crypto);
1937
1938 ::fidl_next::Wire::zero_padding(slot);
1939
1940 ::fidl_next::Wire::zero_padding(dun);
1941
1942 ::fidl_next::Wire::zero_padding(buffers);
1943 }
1944 }
1945
1946 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SdmmcReq<'de>
1947 where
1948 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1949 ___D: ::fidl_next::Decoder<'de>,
1950 ___D: ::fidl_next::fuchsia::HandleDecoder,
1951 {
1952 fn decode(
1953 slot_: ::fidl_next::Slot<'_, Self>,
1954 decoder_: &mut ___D,
1955 _: (),
1956 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1957 ::fidl_next::munge! {
1958 let Self {
1959 mut cmd_idx,
1960 mut cmd_flags,
1961 mut arg,
1962 mut blocksize,
1963 mut suppress_error_messages,
1964 mut client_id,
1965 mut use_inline_crypto,
1966 mut slot,
1967 mut dun,
1968 mut buffers,
1969
1970 } = slot_;
1971 }
1972
1973 let _field = cmd_idx.as_mut();
1974
1975 ::fidl_next::Decode::decode(cmd_idx.as_mut(), decoder_, ())?;
1976
1977 let _field = cmd_flags.as_mut();
1978
1979 ::fidl_next::Decode::decode(cmd_flags.as_mut(), decoder_, ())?;
1980
1981 let _field = arg.as_mut();
1982
1983 ::fidl_next::Decode::decode(arg.as_mut(), decoder_, ())?;
1984
1985 let _field = blocksize.as_mut();
1986
1987 ::fidl_next::Decode::decode(blocksize.as_mut(), decoder_, ())?;
1988
1989 let _field = suppress_error_messages.as_mut();
1990
1991 ::fidl_next::Decode::decode(suppress_error_messages.as_mut(), decoder_, ())?;
1992
1993 let _field = client_id.as_mut();
1994
1995 ::fidl_next::Decode::decode(client_id.as_mut(), decoder_, ())?;
1996
1997 let _field = use_inline_crypto.as_mut();
1998
1999 ::fidl_next::Decode::decode(use_inline_crypto.as_mut(), decoder_, ())?;
2000
2001 let _field = slot.as_mut();
2002
2003 ::fidl_next::Decode::decode(slot.as_mut(), decoder_, ())?;
2004
2005 let _field = dun.as_mut();
2006
2007 ::fidl_next::Decode::decode(dun.as_mut(), decoder_, ())?;
2008
2009 let _field = buffers.as_mut();
2010 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2011 ::fidl_next::Decode::decode(buffers.as_mut(), decoder_, (4294967295, ()))?;
2012
2013 Ok(())
2014 }
2015 }
2016
2017 impl<'de> ::fidl_next::IntoNatural for SdmmcReq<'de> {
2018 type Natural = crate::natural::SdmmcReq;
2019 }
2020
2021 #[derive(Debug)]
2023 #[repr(C)]
2024 pub struct SdmmcRequestRequest<'de> {
2025 pub reqs: ::fidl_next::wire::Vector<'de, crate::wire::SdmmcReq<'de>>,
2026 }
2027
2028 static_assertions::const_assert_eq!(std::mem::size_of::<SdmmcRequestRequest<'_>>(), 16);
2029 static_assertions::const_assert_eq!(std::mem::align_of::<SdmmcRequestRequest<'_>>(), 8);
2030
2031 static_assertions::const_assert_eq!(std::mem::offset_of!(SdmmcRequestRequest<'_>, reqs), 0);
2032
2033 impl ::fidl_next::Constrained for SdmmcRequestRequest<'_> {
2034 type Constraint = ();
2035
2036 fn validate(
2037 _: ::fidl_next::Slot<'_, Self>,
2038 _: Self::Constraint,
2039 ) -> Result<(), ::fidl_next::ValidationError> {
2040 Ok(())
2041 }
2042 }
2043
2044 unsafe impl ::fidl_next::Wire for SdmmcRequestRequest<'static> {
2045 type Narrowed<'de> = SdmmcRequestRequest<'de>;
2046
2047 #[inline]
2048 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2049 ::fidl_next::munge! {
2050 let Self {
2051 reqs,
2052
2053 } = &mut *out_;
2054 }
2055
2056 ::fidl_next::Wire::zero_padding(reqs);
2057 }
2058 }
2059
2060 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SdmmcRequestRequest<'de>
2061 where
2062 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2063 ___D: ::fidl_next::Decoder<'de>,
2064 ___D: ::fidl_next::fuchsia::HandleDecoder,
2065 {
2066 fn decode(
2067 slot_: ::fidl_next::Slot<'_, Self>,
2068 decoder_: &mut ___D,
2069 _: (),
2070 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2071 ::fidl_next::munge! {
2072 let Self {
2073 mut reqs,
2074
2075 } = slot_;
2076 }
2077
2078 let _field = reqs.as_mut();
2079 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2080 ::fidl_next::Decode::decode(reqs.as_mut(), decoder_, (4294967295, ()))?;
2081
2082 Ok(())
2083 }
2084 }
2085
2086 impl<'de> ::fidl_next::IntoNatural for SdmmcRequestRequest<'de> {
2087 type Natural = crate::natural::SdmmcRequestRequest;
2088 }
2089}
2090
2091pub mod wire_optional {
2092
2093 pub use fidl_next_common_fuchsia_hardware_sdmmc::wire_optional::*;
2094
2095 #[repr(transparent)]
2096 pub struct SdmmcBuffer {
2097 pub(crate) raw: ::fidl_next::wire::Union,
2098 pub(crate) _phantom: ::core::marker::PhantomData<()>,
2099 }
2100
2101 impl ::fidl_next::Constrained for SdmmcBuffer {
2102 type Constraint = ();
2103
2104 fn validate(
2105 _: ::fidl_next::Slot<'_, Self>,
2106 _: Self::Constraint,
2107 ) -> Result<(), ::fidl_next::ValidationError> {
2108 Ok(())
2109 }
2110 }
2111
2112 unsafe impl ::fidl_next::Wire for SdmmcBuffer {
2113 type Narrowed<'de> = SdmmcBuffer;
2114
2115 #[inline]
2116 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2117 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2118 ::fidl_next::wire::Union::zero_padding(raw);
2119 }
2120 }
2121
2122 impl SdmmcBuffer {
2123 pub fn is_some(&self) -> bool {
2124 self.raw.is_some()
2125 }
2126
2127 pub fn is_none(&self) -> bool {
2128 self.raw.is_none()
2129 }
2130
2131 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::SdmmcBuffer> {
2132 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
2133 }
2134
2135 pub fn into_option(self) -> ::core::option::Option<crate::wire::SdmmcBuffer> {
2136 if self.is_some() {
2137 Some(crate::wire::SdmmcBuffer {
2138 raw: self.raw,
2139 _phantom: ::core::marker::PhantomData,
2140 })
2141 } else {
2142 None
2143 }
2144 }
2145 }
2146
2147 unsafe impl<___D> ::fidl_next::Decode<___D> for SdmmcBuffer
2148 where
2149 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2150 ___D: ::fidl_next::fuchsia::HandleDecoder,
2151 {
2152 fn decode(
2153 mut slot: ::fidl_next::Slot<'_, Self>,
2154 decoder: &mut ___D,
2155 _: (),
2156 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2157 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2158 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
2159 1 => ::fidl_next::wire::Union::decode_as_static::<___D, ::fidl_next::wire::Uint32>(
2160 raw,
2161 decoder,
2162 (),
2163 )?,
2164
2165 2 => ::fidl_next::wire::Union::decode_as_static::<
2166 ___D,
2167 ::fidl_next::wire::fuchsia::Vmo,
2168 >(raw, decoder, ())?,
2169
2170 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
2171 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
2172 }
2173
2174 Ok(())
2175 }
2176 }
2177
2178 impl ::core::fmt::Debug for SdmmcBuffer {
2179 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2180 self.as_ref().fmt(f)
2181 }
2182 }
2183
2184 impl ::fidl_next::IntoNatural for SdmmcBuffer {
2185 type Natural = ::core::option::Option<crate::natural::SdmmcBuffer>;
2186 }
2187}
2188
2189pub mod generic {
2190
2191 pub use fidl_next_common_fuchsia_hardware_sdmmc::generic::*;
2192
2193 pub struct CqhciInitializeCommandQueueingRequest<T0, T1> {
2195 pub virtual_interrupt: T0,
2196
2197 pub virtual_interrupt_lifeline: T1,
2198 }
2199
2200 unsafe impl<___E, T0, T1>
2201 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingRequest, ___E>
2202 for CqhciInitializeCommandQueueingRequest<T0, T1>
2203 where
2204 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2205 ___E: ::fidl_next::fuchsia::HandleEncoder,
2206 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Interrupt, ___E>,
2207 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
2208 {
2209 #[inline]
2210 fn encode(
2211 self,
2212 encoder_: &mut ___E,
2213 out_: &mut ::core::mem::MaybeUninit<crate::wire::CqhciInitializeCommandQueueingRequest>,
2214 _: (),
2215 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2216 ::fidl_next::munge! {
2217 let crate::wire::CqhciInitializeCommandQueueingRequest {
2218 virtual_interrupt,
2219 virtual_interrupt_lifeline,
2220
2221 } = out_;
2222 }
2223
2224 ::fidl_next::Encode::encode(self.virtual_interrupt, encoder_, virtual_interrupt, ())?;
2225
2226 ::fidl_next::Encode::encode(
2227 self.virtual_interrupt_lifeline,
2228 encoder_,
2229 virtual_interrupt_lifeline,
2230 (),
2231 )?;
2232
2233 Ok(())
2234 }
2235 }
2236
2237 unsafe impl<'a, ___E, T0, T1>
2238 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingRequest, ___E>
2239 for &'a CqhciInitializeCommandQueueingRequest<T0, T1>
2240 where
2241 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2242 ___E: ::fidl_next::fuchsia::HandleEncoder,
2243 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Interrupt, ___E>,
2244 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
2245 {
2246 #[inline]
2247 fn encode(
2248 self,
2249 encoder_: &mut ___E,
2250 out_: &mut ::core::mem::MaybeUninit<crate::wire::CqhciInitializeCommandQueueingRequest>,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 ::fidl_next::munge! {
2254 let crate::wire::CqhciInitializeCommandQueueingRequest {
2255 virtual_interrupt,
2256 virtual_interrupt_lifeline,
2257
2258 } = out_;
2259 }
2260
2261 ::fidl_next::Encode::encode(&self.virtual_interrupt, encoder_, virtual_interrupt, ())?;
2262
2263 ::fidl_next::Encode::encode(
2264 &self.virtual_interrupt_lifeline,
2265 encoder_,
2266 virtual_interrupt_lifeline,
2267 (),
2268 )?;
2269
2270 Ok(())
2271 }
2272 }
2273
2274 pub struct CqhciInitializeCommandQueueingResponse<T0, T1, T2, T3, T4, T5> {
2276 pub cqhci_mmio: T0,
2277
2278 pub cqhci_mmio_offset: T1,
2279
2280 pub sdhci_mmio: T2,
2281
2282 pub sdhci_mmio_offset: T3,
2283
2284 pub bti: T4,
2285
2286 pub interrupt: T5,
2287 }
2288
2289 unsafe impl<___E, T0, T1, T2, T3, T4, T5>
2290 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingResponse, ___E>
2291 for CqhciInitializeCommandQueueingResponse<T0, T1, T2, T3, T4, T5>
2292 where
2293 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2294 ___E: ::fidl_next::fuchsia::HandleEncoder,
2295 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2296 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2297 T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2298 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2299 T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Bti, ___E>,
2300 T5: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Interrupt, ___E>,
2301 {
2302 #[inline]
2303 fn encode(
2304 self,
2305 encoder_: &mut ___E,
2306 out_: &mut ::core::mem::MaybeUninit<
2307 crate::wire::CqhciInitializeCommandQueueingResponse,
2308 >,
2309 _: (),
2310 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2311 ::fidl_next::munge! {
2312 let crate::wire::CqhciInitializeCommandQueueingResponse {
2313 cqhci_mmio,
2314 cqhci_mmio_offset,
2315 sdhci_mmio,
2316 sdhci_mmio_offset,
2317 bti,
2318 interrupt,
2319
2320 } = out_;
2321 }
2322
2323 ::fidl_next::Encode::encode(self.cqhci_mmio, encoder_, cqhci_mmio, ())?;
2324
2325 ::fidl_next::Encode::encode(self.cqhci_mmio_offset, encoder_, cqhci_mmio_offset, ())?;
2326
2327 ::fidl_next::Encode::encode(self.sdhci_mmio, encoder_, sdhci_mmio, ())?;
2328
2329 ::fidl_next::Encode::encode(self.sdhci_mmio_offset, encoder_, sdhci_mmio_offset, ())?;
2330
2331 ::fidl_next::Encode::encode(self.bti, encoder_, bti, ())?;
2332
2333 ::fidl_next::Encode::encode(self.interrupt, encoder_, interrupt, ())?;
2334
2335 Ok(())
2336 }
2337 }
2338
2339 unsafe impl<'a, ___E, T0, T1, T2, T3, T4, T5>
2340 ::fidl_next::Encode<crate::wire::CqhciInitializeCommandQueueingResponse, ___E>
2341 for &'a CqhciInitializeCommandQueueingResponse<T0, T1, T2, T3, T4, T5>
2342 where
2343 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2344 ___E: ::fidl_next::fuchsia::HandleEncoder,
2345 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2346 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2347 &'a T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2348 &'a T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2349 &'a T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Bti, ___E>,
2350 &'a T5: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Interrupt, ___E>,
2351 {
2352 #[inline]
2353 fn encode(
2354 self,
2355 encoder_: &mut ___E,
2356 out_: &mut ::core::mem::MaybeUninit<
2357 crate::wire::CqhciInitializeCommandQueueingResponse,
2358 >,
2359 _: (),
2360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2361 ::fidl_next::munge! {
2362 let crate::wire::CqhciInitializeCommandQueueingResponse {
2363 cqhci_mmio,
2364 cqhci_mmio_offset,
2365 sdhci_mmio,
2366 sdhci_mmio_offset,
2367 bti,
2368 interrupt,
2369
2370 } = out_;
2371 }
2372
2373 ::fidl_next::Encode::encode(&self.cqhci_mmio, encoder_, cqhci_mmio, ())?;
2374
2375 ::fidl_next::Encode::encode(&self.cqhci_mmio_offset, encoder_, cqhci_mmio_offset, ())?;
2376
2377 ::fidl_next::Encode::encode(&self.sdhci_mmio, encoder_, sdhci_mmio, ())?;
2378
2379 ::fidl_next::Encode::encode(&self.sdhci_mmio_offset, encoder_, sdhci_mmio_offset, ())?;
2380
2381 ::fidl_next::Encode::encode(&self.bti, encoder_, bti, ())?;
2382
2383 ::fidl_next::Encode::encode(&self.interrupt, encoder_, interrupt, ())?;
2384
2385 Ok(())
2386 }
2387 }
2388
2389 pub struct SdmmcRegisterInBandInterruptRequest<T0> {
2391 pub interrupt_cb: T0,
2392 }
2393
2394 unsafe impl<___E, T0>
2395 ::fidl_next::Encode<crate::wire::SdmmcRegisterInBandInterruptRequest, ___E>
2396 for SdmmcRegisterInBandInterruptRequest<T0>
2397 where
2398 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2399 ___E: ::fidl_next::fuchsia::HandleEncoder,
2400 T0: ::fidl_next::Encode<
2401 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>,
2402 ___E,
2403 >,
2404 {
2405 #[inline]
2406 fn encode(
2407 self,
2408 encoder_: &mut ___E,
2409 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterInBandInterruptRequest>,
2410 _: (),
2411 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2412 ::fidl_next::munge! {
2413 let crate::wire::SdmmcRegisterInBandInterruptRequest {
2414 interrupt_cb,
2415
2416 } = out_;
2417 }
2418
2419 ::fidl_next::Encode::encode(self.interrupt_cb, encoder_, interrupt_cb, ())?;
2420
2421 Ok(())
2422 }
2423 }
2424
2425 unsafe impl<'a, ___E, T0>
2426 ::fidl_next::Encode<crate::wire::SdmmcRegisterInBandInterruptRequest, ___E>
2427 for &'a SdmmcRegisterInBandInterruptRequest<T0>
2428 where
2429 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2430 ___E: ::fidl_next::fuchsia::HandleEncoder,
2431 &'a T0: ::fidl_next::Encode<
2432 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>,
2433 ___E,
2434 >,
2435 {
2436 #[inline]
2437 fn encode(
2438 self,
2439 encoder_: &mut ___E,
2440 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterInBandInterruptRequest>,
2441 _: (),
2442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2443 ::fidl_next::munge! {
2444 let crate::wire::SdmmcRegisterInBandInterruptRequest {
2445 interrupt_cb,
2446
2447 } = out_;
2448 }
2449
2450 ::fidl_next::Encode::encode(&self.interrupt_cb, encoder_, interrupt_cb, ())?;
2451
2452 Ok(())
2453 }
2454 }
2455
2456 pub struct SdmmcRegisterVmoRequest<T0, T1, T2, T3, T4, T5> {
2458 pub vmo_id: T0,
2459
2460 pub client_id: T1,
2461
2462 pub vmo: T2,
2463
2464 pub offset: T3,
2465
2466 pub size: T4,
2467
2468 pub vmo_rights: T5,
2469 }
2470
2471 unsafe impl<___E, T0, T1, T2, T3, T4, T5>
2472 ::fidl_next::Encode<crate::wire::SdmmcRegisterVmoRequest, ___E>
2473 for SdmmcRegisterVmoRequest<T0, T1, T2, T3, T4, T5>
2474 where
2475 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2476 ___E: ::fidl_next::fuchsia::HandleEncoder,
2477 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2478 T1: ::fidl_next::Encode<u8, ___E>,
2479 T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2480 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2481 T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2482 T5: ::fidl_next::Encode<crate::wire::SdmmcVmoRight, ___E>,
2483 {
2484 #[inline]
2485 fn encode(
2486 self,
2487 encoder_: &mut ___E,
2488 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterVmoRequest>,
2489 _: (),
2490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2491 ::fidl_next::munge! {
2492 let crate::wire::SdmmcRegisterVmoRequest {
2493 vmo_id,
2494 client_id,
2495 vmo,
2496 offset,
2497 size,
2498 vmo_rights,
2499
2500 } = out_;
2501 }
2502
2503 ::fidl_next::Encode::encode(self.vmo_id, encoder_, vmo_id, ())?;
2504
2505 ::fidl_next::Encode::encode(self.client_id, encoder_, client_id, ())?;
2506
2507 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
2508
2509 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
2510
2511 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
2512
2513 ::fidl_next::Encode::encode(self.vmo_rights, encoder_, vmo_rights, ())?;
2514
2515 Ok(())
2516 }
2517 }
2518
2519 unsafe impl<'a, ___E, T0, T1, T2, T3, T4, T5>
2520 ::fidl_next::Encode<crate::wire::SdmmcRegisterVmoRequest, ___E>
2521 for &'a SdmmcRegisterVmoRequest<T0, T1, T2, T3, T4, T5>
2522 where
2523 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2524 ___E: ::fidl_next::fuchsia::HandleEncoder,
2525 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2526 &'a T1: ::fidl_next::Encode<u8, ___E>,
2527 &'a T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2528 &'a T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2529 &'a T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2530 &'a T5: ::fidl_next::Encode<crate::wire::SdmmcVmoRight, ___E>,
2531 {
2532 #[inline]
2533 fn encode(
2534 self,
2535 encoder_: &mut ___E,
2536 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRegisterVmoRequest>,
2537 _: (),
2538 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2539 ::fidl_next::munge! {
2540 let crate::wire::SdmmcRegisterVmoRequest {
2541 vmo_id,
2542 client_id,
2543 vmo,
2544 offset,
2545 size,
2546 vmo_rights,
2547
2548 } = out_;
2549 }
2550
2551 ::fidl_next::Encode::encode(&self.vmo_id, encoder_, vmo_id, ())?;
2552
2553 ::fidl_next::Encode::encode(&self.client_id, encoder_, client_id, ())?;
2554
2555 ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
2556
2557 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
2558
2559 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
2560
2561 ::fidl_next::Encode::encode(&self.vmo_rights, encoder_, vmo_rights, ())?;
2562
2563 Ok(())
2564 }
2565 }
2566
2567 pub struct SdmmcUnregisterVmoResponse<T0> {
2569 pub vmo: T0,
2570 }
2571
2572 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SdmmcUnregisterVmoResponse, ___E>
2573 for SdmmcUnregisterVmoResponse<T0>
2574 where
2575 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2576 ___E: ::fidl_next::fuchsia::HandleEncoder,
2577 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2578 {
2579 #[inline]
2580 fn encode(
2581 self,
2582 encoder_: &mut ___E,
2583 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcUnregisterVmoResponse>,
2584 _: (),
2585 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2586 ::fidl_next::munge! {
2587 let crate::wire::SdmmcUnregisterVmoResponse {
2588 vmo,
2589
2590 } = out_;
2591 }
2592
2593 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
2594
2595 Ok(())
2596 }
2597 }
2598
2599 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::SdmmcUnregisterVmoResponse, ___E>
2600 for &'a SdmmcUnregisterVmoResponse<T0>
2601 where
2602 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2603 ___E: ::fidl_next::fuchsia::HandleEncoder,
2604 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2605 {
2606 #[inline]
2607 fn encode(
2608 self,
2609 encoder_: &mut ___E,
2610 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcUnregisterVmoResponse>,
2611 _: (),
2612 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2613 ::fidl_next::munge! {
2614 let crate::wire::SdmmcUnregisterVmoResponse {
2615 vmo,
2616
2617 } = out_;
2618 }
2619
2620 ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
2621
2622 Ok(())
2623 }
2624 }
2625
2626 pub struct SdmmcBufferRegion<T0, T1, T2> {
2628 pub buffer: T0,
2629
2630 pub offset: T1,
2631
2632 pub size: T2,
2633 }
2634
2635 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::SdmmcBufferRegion, ___E>
2636 for SdmmcBufferRegion<T0, T1, T2>
2637 where
2638 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2639 ___E: ::fidl_next::fuchsia::HandleEncoder,
2640 T0: ::fidl_next::Encode<crate::wire::SdmmcBuffer, ___E>,
2641 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2642 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2643 {
2644 #[inline]
2645 fn encode(
2646 self,
2647 encoder_: &mut ___E,
2648 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcBufferRegion>,
2649 _: (),
2650 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2651 ::fidl_next::munge! {
2652 let crate::wire::SdmmcBufferRegion {
2653 buffer,
2654 offset,
2655 size,
2656
2657 } = out_;
2658 }
2659
2660 ::fidl_next::Encode::encode(self.buffer, encoder_, buffer, ())?;
2661
2662 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
2663
2664 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
2665
2666 Ok(())
2667 }
2668 }
2669
2670 unsafe impl<'a, ___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::SdmmcBufferRegion, ___E>
2671 for &'a SdmmcBufferRegion<T0, T1, T2>
2672 where
2673 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2674 ___E: ::fidl_next::fuchsia::HandleEncoder,
2675 &'a T0: ::fidl_next::Encode<crate::wire::SdmmcBuffer, ___E>,
2676 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2677 &'a T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2678 {
2679 #[inline]
2680 fn encode(
2681 self,
2682 encoder_: &mut ___E,
2683 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcBufferRegion>,
2684 _: (),
2685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2686 ::fidl_next::munge! {
2687 let crate::wire::SdmmcBufferRegion {
2688 buffer,
2689 offset,
2690 size,
2691
2692 } = out_;
2693 }
2694
2695 ::fidl_next::Encode::encode(&self.buffer, encoder_, buffer, ())?;
2696
2697 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
2698
2699 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
2700
2701 Ok(())
2702 }
2703 }
2704
2705 pub struct SdmmcReq<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
2707 pub cmd_idx: T0,
2708
2709 pub cmd_flags: T1,
2710
2711 pub arg: T2,
2712
2713 pub blocksize: T3,
2714
2715 pub suppress_error_messages: T4,
2716
2717 pub client_id: T5,
2718
2719 pub use_inline_crypto: T6,
2720
2721 pub slot: T7,
2722
2723 pub dun: T8,
2724
2725 pub buffers: T9,
2726 }
2727
2728 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
2729 ::fidl_next::Encode<crate::wire::SdmmcReq<'static>, ___E>
2730 for SdmmcReq<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
2731 where
2732 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2733 ___E: ::fidl_next::Encoder,
2734 ___E: ::fidl_next::fuchsia::HandleEncoder,
2735 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2736 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2737 T2: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2738 T3: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2739 T4: ::fidl_next::Encode<bool, ___E>,
2740 T5: ::fidl_next::Encode<u8, ___E>,
2741 T6: ::fidl_next::Encode<bool, ___E>,
2742 T7: ::fidl_next::Encode<u8, ___E>,
2743 T8: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2744 T9: ::fidl_next::Encode<
2745 ::fidl_next::wire::Vector<'static, crate::wire::SdmmcBufferRegion>,
2746 ___E,
2747 >,
2748 {
2749 #[inline]
2750 fn encode(
2751 self,
2752 encoder_: &mut ___E,
2753 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcReq<'static>>,
2754 _: (),
2755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2756 ::fidl_next::munge! {
2757 let crate::wire::SdmmcReq {
2758 cmd_idx,
2759 cmd_flags,
2760 arg,
2761 blocksize,
2762 suppress_error_messages,
2763 client_id,
2764 use_inline_crypto,
2765 slot,
2766 dun,
2767 buffers,
2768
2769 } = out_;
2770 }
2771
2772 ::fidl_next::Encode::encode(self.cmd_idx, encoder_, cmd_idx, ())?;
2773
2774 ::fidl_next::Encode::encode(self.cmd_flags, encoder_, cmd_flags, ())?;
2775
2776 ::fidl_next::Encode::encode(self.arg, encoder_, arg, ())?;
2777
2778 ::fidl_next::Encode::encode(self.blocksize, encoder_, blocksize, ())?;
2779
2780 ::fidl_next::Encode::encode(
2781 self.suppress_error_messages,
2782 encoder_,
2783 suppress_error_messages,
2784 (),
2785 )?;
2786
2787 ::fidl_next::Encode::encode(self.client_id, encoder_, client_id, ())?;
2788
2789 ::fidl_next::Encode::encode(self.use_inline_crypto, encoder_, use_inline_crypto, ())?;
2790
2791 ::fidl_next::Encode::encode(self.slot, encoder_, slot, ())?;
2792
2793 ::fidl_next::Encode::encode(self.dun, encoder_, dun, ())?;
2794
2795 ::fidl_next::Encode::encode(self.buffers, encoder_, buffers, (4294967295, ()))?;
2796
2797 Ok(())
2798 }
2799 }
2800
2801 unsafe impl<'a, ___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
2802 ::fidl_next::Encode<crate::wire::SdmmcReq<'static>, ___E>
2803 for &'a SdmmcReq<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
2804 where
2805 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2806 ___E: ::fidl_next::Encoder,
2807 ___E: ::fidl_next::fuchsia::HandleEncoder,
2808 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2809 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2810 &'a T2: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2811 &'a T3: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2812 &'a T4: ::fidl_next::Encode<bool, ___E>,
2813 &'a T5: ::fidl_next::Encode<u8, ___E>,
2814 &'a T6: ::fidl_next::Encode<bool, ___E>,
2815 &'a T7: ::fidl_next::Encode<u8, ___E>,
2816 &'a T8: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2817 &'a T9: ::fidl_next::Encode<
2818 ::fidl_next::wire::Vector<'static, crate::wire::SdmmcBufferRegion>,
2819 ___E,
2820 >,
2821 {
2822 #[inline]
2823 fn encode(
2824 self,
2825 encoder_: &mut ___E,
2826 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcReq<'static>>,
2827 _: (),
2828 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2829 ::fidl_next::munge! {
2830 let crate::wire::SdmmcReq {
2831 cmd_idx,
2832 cmd_flags,
2833 arg,
2834 blocksize,
2835 suppress_error_messages,
2836 client_id,
2837 use_inline_crypto,
2838 slot,
2839 dun,
2840 buffers,
2841
2842 } = out_;
2843 }
2844
2845 ::fidl_next::Encode::encode(&self.cmd_idx, encoder_, cmd_idx, ())?;
2846
2847 ::fidl_next::Encode::encode(&self.cmd_flags, encoder_, cmd_flags, ())?;
2848
2849 ::fidl_next::Encode::encode(&self.arg, encoder_, arg, ())?;
2850
2851 ::fidl_next::Encode::encode(&self.blocksize, encoder_, blocksize, ())?;
2852
2853 ::fidl_next::Encode::encode(
2854 &self.suppress_error_messages,
2855 encoder_,
2856 suppress_error_messages,
2857 (),
2858 )?;
2859
2860 ::fidl_next::Encode::encode(&self.client_id, encoder_, client_id, ())?;
2861
2862 ::fidl_next::Encode::encode(&self.use_inline_crypto, encoder_, use_inline_crypto, ())?;
2863
2864 ::fidl_next::Encode::encode(&self.slot, encoder_, slot, ())?;
2865
2866 ::fidl_next::Encode::encode(&self.dun, encoder_, dun, ())?;
2867
2868 ::fidl_next::Encode::encode(&self.buffers, encoder_, buffers, (4294967295, ()))?;
2869
2870 Ok(())
2871 }
2872 }
2873
2874 pub struct SdmmcRequestRequest<T0> {
2876 pub reqs: T0,
2877 }
2878
2879 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SdmmcRequestRequest<'static>, ___E>
2880 for SdmmcRequestRequest<T0>
2881 where
2882 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2883 ___E: ::fidl_next::Encoder,
2884 ___E: ::fidl_next::fuchsia::HandleEncoder,
2885 T0: ::fidl_next::Encode<
2886 ::fidl_next::wire::Vector<'static, crate::wire::SdmmcReq<'static>>,
2887 ___E,
2888 >,
2889 {
2890 #[inline]
2891 fn encode(
2892 self,
2893 encoder_: &mut ___E,
2894 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRequestRequest<'static>>,
2895 _: (),
2896 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2897 ::fidl_next::munge! {
2898 let crate::wire::SdmmcRequestRequest {
2899 reqs,
2900
2901 } = out_;
2902 }
2903
2904 ::fidl_next::Encode::encode(self.reqs, encoder_, reqs, (4294967295, ()))?;
2905
2906 Ok(())
2907 }
2908 }
2909
2910 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::SdmmcRequestRequest<'static>, ___E>
2911 for &'a SdmmcRequestRequest<T0>
2912 where
2913 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2914 ___E: ::fidl_next::Encoder,
2915 ___E: ::fidl_next::fuchsia::HandleEncoder,
2916 &'a T0: ::fidl_next::Encode<
2917 ::fidl_next::wire::Vector<'static, crate::wire::SdmmcReq<'static>>,
2918 ___E,
2919 >,
2920 {
2921 #[inline]
2922 fn encode(
2923 self,
2924 encoder_: &mut ___E,
2925 out_: &mut ::core::mem::MaybeUninit<crate::wire::SdmmcRequestRequest<'static>>,
2926 _: (),
2927 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2928 ::fidl_next::munge! {
2929 let crate::wire::SdmmcRequestRequest {
2930 reqs,
2931
2932 } = out_;
2933 }
2934
2935 ::fidl_next::Encode::encode(&self.reqs, encoder_, reqs, (4294967295, ()))?;
2936
2937 Ok(())
2938 }
2939 }
2940}
2941
2942pub use self::natural::*;
2943
2944#[derive(PartialEq, Debug)]
2946pub struct Cqhci;
2947
2948#[cfg(feature = "driver")]
2949impl ::fidl_next::HasTransport for Cqhci {
2950 type Transport = ::fdf_fidl::DriverChannel;
2951}
2952
2953pub mod cqhci {
2954 pub mod prelude {
2955 pub use crate::{
2956 Cqhci, CqhciClientHandler, CqhciLocalClientHandler, CqhciLocalServerHandler,
2957 CqhciServerHandler, cqhci,
2958 };
2959
2960 pub use crate::natural::CqhciInitializeCommandQueueingRequest;
2961
2962 pub use crate::natural::CqhciDisableCqhciResponse;
2963
2964 pub use crate::natural::CqhciEnableCqhciResponse;
2965
2966 pub use crate::natural::CqhciInitializeCommandQueueingResponse;
2967 }
2968
2969 pub struct InitializeCommandQueueing;
2970
2971 impl ::fidl_next::Method for InitializeCommandQueueing {
2972 const ORDINAL: u64 = 359559202570093266;
2973 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2974 ::fidl_next::protocol::Flexibility::Strict;
2975
2976 type Protocol = crate::Cqhci;
2977
2978 type Request = crate::wire::CqhciInitializeCommandQueueingRequest;
2979 }
2980
2981 impl ::fidl_next::TwoWayMethod for InitializeCommandQueueing {
2982 type Response = ::fidl_next::wire::Result<
2983 'static,
2984 crate::wire::CqhciInitializeCommandQueueingResponse,
2985 ::fidl_next::wire::fuchsia::Status,
2986 >;
2987 }
2988
2989 impl<___R> ::fidl_next::Respond<___R> for InitializeCommandQueueing {
2990 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
2991
2992 fn respond(response: ___R) -> Self::Output {
2993 ::core::result::Result::Ok(response)
2994 }
2995 }
2996
2997 impl<___R> ::fidl_next::RespondErr<___R> for InitializeCommandQueueing {
2998 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
2999
3000 fn respond_err(response: ___R) -> Self::Output {
3001 ::core::result::Result::Err(response)
3002 }
3003 }
3004
3005 pub struct EnableCqhci;
3006
3007 impl ::fidl_next::Method for EnableCqhci {
3008 const ORDINAL: u64 = 7267012061448928954;
3009 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3010 ::fidl_next::protocol::Flexibility::Strict;
3011
3012 type Protocol = crate::Cqhci;
3013
3014 type Request = ::fidl_next::wire::EmptyMessageBody;
3015 }
3016
3017 impl ::fidl_next::TwoWayMethod for EnableCqhci {
3018 type Response = ::fidl_next::wire::Result<
3019 'static,
3020 crate::wire::CqhciEnableCqhciResponse,
3021 ::fidl_next::wire::fuchsia::Status,
3022 >;
3023 }
3024
3025 impl<___R> ::fidl_next::Respond<___R> for EnableCqhci {
3026 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3027
3028 fn respond(response: ___R) -> Self::Output {
3029 ::core::result::Result::Ok(response)
3030 }
3031 }
3032
3033 impl<___R> ::fidl_next::RespondErr<___R> for EnableCqhci {
3034 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3035
3036 fn respond_err(response: ___R) -> Self::Output {
3037 ::core::result::Result::Err(response)
3038 }
3039 }
3040
3041 pub struct DisableCqhci;
3042
3043 impl ::fidl_next::Method for DisableCqhci {
3044 const ORDINAL: u64 = 4177196635683073751;
3045 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3046 ::fidl_next::protocol::Flexibility::Strict;
3047
3048 type Protocol = crate::Cqhci;
3049
3050 type Request = ::fidl_next::wire::EmptyMessageBody;
3051 }
3052
3053 impl ::fidl_next::TwoWayMethod for DisableCqhci {
3054 type Response = ::fidl_next::wire::Result<
3055 'static,
3056 crate::wire::CqhciDisableCqhciResponse,
3057 ::fidl_next::wire::fuchsia::Status,
3058 >;
3059 }
3060
3061 impl<___R> ::fidl_next::Respond<___R> for DisableCqhci {
3062 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3063
3064 fn respond(response: ___R) -> Self::Output {
3065 ::core::result::Result::Ok(response)
3066 }
3067 }
3068
3069 impl<___R> ::fidl_next::RespondErr<___R> for DisableCqhci {
3070 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3071
3072 fn respond_err(response: ___R) -> Self::Output {
3073 ::core::result::Result::Err(response)
3074 }
3075 }
3076
3077 mod ___detail {
3078 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Cqhci
3079 where
3080 ___T: ::fidl_next::Transport,
3081 {
3082 type Client = CqhciClient<___T>;
3083 type Server = CqhciServer<___T>;
3084 }
3085
3086 #[repr(transparent)]
3088 pub struct CqhciClient<___T: ::fidl_next::Transport> {
3089 #[allow(dead_code)]
3090 client: ::fidl_next::protocol::Client<___T>,
3091 }
3092
3093 impl<___T> CqhciClient<___T>
3094 where
3095 ___T: ::fidl_next::Transport,
3096 {
3097 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
3098 pub fn initialize_command_queueing(
3099 &self,
3100
3101 virtual_interrupt: impl ::fidl_next::Encode<
3102 ::fidl_next::wire::fuchsia::Interrupt,
3103 <___T as ::fidl_next::Transport>::SendBuffer,
3104 >,
3105
3106 virtual_interrupt_lifeline: impl ::fidl_next::Encode<
3107 ::fidl_next::wire::fuchsia::EventPair,
3108 <___T as ::fidl_next::Transport>::SendBuffer,
3109 >,
3110 ) -> ::fidl_next::TwoWayFuture<'_, super::InitializeCommandQueueing, ___T>
3111 where
3112 <___T as ::fidl_next::Transport>::SendBuffer:
3113 ::fidl_next::encoder::InternalHandleEncoder,
3114 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
3115 {
3116 self.initialize_command_queueing_with(
3117 crate::generic::CqhciInitializeCommandQueueingRequest {
3118 virtual_interrupt,
3119
3120 virtual_interrupt_lifeline,
3121 },
3122 )
3123 }
3124
3125 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
3126 pub fn initialize_command_queueing_with<___R>(
3127 &self,
3128 request: ___R,
3129 ) -> ::fidl_next::TwoWayFuture<'_, super::InitializeCommandQueueing, ___T>
3130 where
3131 ___R: ::fidl_next::Encode<
3132 crate::wire::CqhciInitializeCommandQueueingRequest,
3133 <___T as ::fidl_next::Transport>::SendBuffer,
3134 >,
3135 {
3136 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
3137 359559202570093266,
3138 <super::InitializeCommandQueueing as ::fidl_next::Method>::FLEXIBILITY,
3139 request,
3140 ))
3141 }
3142
3143 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
3144 pub fn enable_cqhci(&self) -> ::fidl_next::TwoWayFuture<'_, super::EnableCqhci, ___T> {
3145 ::fidl_next::TwoWayFuture::from_untyped(
3146 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
3147 7267012061448928954,
3148 <super::EnableCqhci as ::fidl_next::Method>::FLEXIBILITY,
3149 (),
3150 ),
3151 )
3152 }
3153
3154 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
3155 pub fn disable_cqhci(
3156 &self,
3157 ) -> ::fidl_next::TwoWayFuture<'_, super::DisableCqhci, ___T> {
3158 ::fidl_next::TwoWayFuture::from_untyped(
3159 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
3160 4177196635683073751,
3161 <super::DisableCqhci as ::fidl_next::Method>::FLEXIBILITY,
3162 (),
3163 ),
3164 )
3165 }
3166 }
3167
3168 #[repr(transparent)]
3170 pub struct CqhciServer<___T: ::fidl_next::Transport> {
3171 server: ::fidl_next::protocol::Server<___T>,
3172 }
3173
3174 impl<___T> CqhciServer<___T> where ___T: ::fidl_next::Transport {}
3175 }
3176}
3177
3178#[diagnostic::on_unimplemented(
3179 note = "If {Self} implements the non-local CqhciClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
3180)]
3181
3182pub trait CqhciLocalClientHandler<
3186 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
3187 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
3188>
3189{
3190}
3191
3192impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Cqhci
3193where
3194 ___H: CqhciLocalClientHandler<___T>,
3195 ___T: ::fidl_next::Transport,
3196{
3197 async fn on_event(
3198 handler: &mut ___H,
3199 mut message: ::fidl_next::Message<___T>,
3200 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3201 match *message.header().ordinal {
3202 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3203 }
3204 }
3205}
3206
3207#[diagnostic::on_unimplemented(
3208 note = "If {Self} implements the non-local CqhciServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
3209)]
3210
3211pub trait CqhciLocalServerHandler<
3215 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
3216 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
3217>
3218{
3219 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
3220 fn initialize_command_queueing(
3221 &mut self,
3222
3223 request: ::fidl_next::Request<cqhci::InitializeCommandQueueing, ___T>,
3224
3225 responder: ::fidl_next::Responder<cqhci::InitializeCommandQueueing, ___T>,
3226 ) -> impl ::core::future::Future<Output = ()>;
3227
3228 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
3229 fn enable_cqhci(
3230 &mut self,
3231
3232 responder: ::fidl_next::Responder<cqhci::EnableCqhci, ___T>,
3233 ) -> impl ::core::future::Future<Output = ()>;
3234
3235 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
3236 fn disable_cqhci(
3237 &mut self,
3238
3239 responder: ::fidl_next::Responder<cqhci::DisableCqhci, ___T>,
3240 ) -> impl ::core::future::Future<Output = ()>;
3241}
3242
3243impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Cqhci
3244where
3245 ___H: CqhciLocalServerHandler<___T>,
3246 ___T: ::fidl_next::Transport,
3247 for<'de> crate::wire::CqhciInitializeCommandQueueingRequest: ::fidl_next::Decode<
3248 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3249 Constraint = (),
3250 >,
3251{
3252 async fn on_one_way(
3253 handler: &mut ___H,
3254 mut message: ::fidl_next::Message<___T>,
3255 ) -> ::core::result::Result<
3256 (),
3257 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3258 > {
3259 match *message.header().ordinal {
3260 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3261 }
3262 }
3263
3264 async fn on_two_way(
3265 handler: &mut ___H,
3266 mut message: ::fidl_next::Message<___T>,
3267 responder: ::fidl_next::protocol::Responder<___T>,
3268 ) -> ::core::result::Result<
3269 (),
3270 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3271 > {
3272 match *message.header().ordinal {
3273 359559202570093266 => {
3274 let responder = ::fidl_next::Responder::from_untyped(responder);
3275
3276 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3277 Ok(decoded) => {
3278 handler
3279 .initialize_command_queueing(
3280 ::fidl_next::Request::from_decoded(decoded),
3281 responder,
3282 )
3283 .await;
3284 Ok(())
3285 }
3286 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3287 ordinal: 359559202570093266,
3288 error,
3289 }),
3290 }
3291 }
3292
3293 7267012061448928954 => {
3294 let responder = ::fidl_next::Responder::from_untyped(responder);
3295
3296 handler.enable_cqhci(responder).await;
3297 Ok(())
3298 }
3299
3300 4177196635683073751 => {
3301 let responder = ::fidl_next::Responder::from_untyped(responder);
3302
3303 handler.disable_cqhci(responder).await;
3304 Ok(())
3305 }
3306
3307 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3308 }
3309 }
3310}
3311
3312pub trait CqhciClientHandler<
3316 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
3317 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
3318>
3319{
3320}
3321
3322impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Cqhci
3323where
3324 ___H: CqhciClientHandler<___T> + ::core::marker::Send,
3325 ___T: ::fidl_next::Transport,
3326{
3327 async fn on_event(
3328 handler: &mut ___H,
3329 mut message: ::fidl_next::Message<___T>,
3330 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3331 match *message.header().ordinal {
3332 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3333 }
3334 }
3335}
3336
3337pub trait CqhciServerHandler<
3341 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
3342 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
3343>
3344{
3345 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
3346 fn initialize_command_queueing(
3347 &mut self,
3348
3349 request: ::fidl_next::Request<cqhci::InitializeCommandQueueing, ___T>,
3350
3351 responder: ::fidl_next::Responder<cqhci::InitializeCommandQueueing, ___T>,
3352 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3353
3354 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
3355 fn enable_cqhci(
3356 &mut self,
3357
3358 responder: ::fidl_next::Responder<cqhci::EnableCqhci, ___T>,
3359 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3360
3361 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
3362 fn disable_cqhci(
3363 &mut self,
3364
3365 responder: ::fidl_next::Responder<cqhci::DisableCqhci, ___T>,
3366 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3367}
3368
3369impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Cqhci
3370where
3371 ___H: CqhciServerHandler<___T> + ::core::marker::Send,
3372 ___T: ::fidl_next::Transport,
3373 for<'de> crate::wire::CqhciInitializeCommandQueueingRequest: ::fidl_next::Decode<
3374 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3375 Constraint = (),
3376 >,
3377{
3378 async fn on_one_way(
3379 handler: &mut ___H,
3380 mut message: ::fidl_next::Message<___T>,
3381 ) -> ::core::result::Result<
3382 (),
3383 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3384 > {
3385 match *message.header().ordinal {
3386 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3387 }
3388 }
3389
3390 async fn on_two_way(
3391 handler: &mut ___H,
3392 mut message: ::fidl_next::Message<___T>,
3393 responder: ::fidl_next::protocol::Responder<___T>,
3394 ) -> ::core::result::Result<
3395 (),
3396 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3397 > {
3398 match *message.header().ordinal {
3399 359559202570093266 => {
3400 let responder = ::fidl_next::Responder::from_untyped(responder);
3401
3402 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3403 Ok(decoded) => {
3404 handler
3405 .initialize_command_queueing(
3406 ::fidl_next::Request::from_decoded(decoded),
3407 responder,
3408 )
3409 .await;
3410 Ok(())
3411 }
3412 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3413 ordinal: 359559202570093266,
3414 error,
3415 }),
3416 }
3417 }
3418
3419 7267012061448928954 => {
3420 let responder = ::fidl_next::Responder::from_untyped(responder);
3421
3422 handler.enable_cqhci(responder).await;
3423 Ok(())
3424 }
3425
3426 4177196635683073751 => {
3427 let responder = ::fidl_next::Responder::from_untyped(responder);
3428
3429 handler.disable_cqhci(responder).await;
3430 Ok(())
3431 }
3432
3433 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3434 }
3435 }
3436}
3437
3438impl<___T> CqhciClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
3439
3440impl<___H, ___T> CqhciLocalClientHandler<___T> for ::fidl_next::Local<___H>
3441where
3442 ___H: CqhciClientHandler<___T>,
3443 ___T: ::fidl_next::Transport,
3444{
3445}
3446
3447impl<___H, ___T> CqhciLocalServerHandler<___T> for ::fidl_next::Local<___H>
3448where
3449 ___H: CqhciServerHandler<___T>,
3450 ___T: ::fidl_next::Transport,
3451{
3452 async fn initialize_command_queueing(
3453 &mut self,
3454
3455 request: ::fidl_next::Request<cqhci::InitializeCommandQueueing, ___T>,
3456
3457 responder: ::fidl_next::Responder<cqhci::InitializeCommandQueueing, ___T>,
3458 ) {
3459 ___H::initialize_command_queueing(&mut self.0, request, responder).await
3460 }
3461
3462 async fn enable_cqhci(&mut self, responder: ::fidl_next::Responder<cqhci::EnableCqhci, ___T>) {
3463 ___H::enable_cqhci(&mut self.0, responder).await
3464 }
3465
3466 async fn disable_cqhci(
3467 &mut self,
3468
3469 responder: ::fidl_next::Responder<cqhci::DisableCqhci, ___T>,
3470 ) {
3471 ___H::disable_cqhci(&mut self.0, responder).await
3472 }
3473}
3474
3475#[derive(PartialEq, Debug)]
3477pub struct Sdmmc;
3478
3479impl ::fidl_next::Discoverable for Sdmmc {
3480 const PROTOCOL_NAME: &'static str = "fuchsia.hardware.sdmmc.Sdmmc";
3481}
3482
3483#[cfg(feature = "driver")]
3484impl ::fidl_next::HasTransport for Sdmmc {
3485 type Transport = ::fdf_fidl::DriverChannel;
3486}
3487
3488pub mod sdmmc {
3489 pub mod prelude {
3490 pub use crate::{
3491 Sdmmc, SdmmcClientHandler, SdmmcLocalClientHandler, SdmmcLocalServerHandler,
3492 SdmmcServerHandler, sdmmc,
3493 };
3494
3495 pub use crate::natural::CqhciInitializeCommandQueueingRequest;
3496
3497 pub use crate::natural::CqhciDisableCqhciResponse;
3498
3499 pub use crate::natural::CqhciEnableCqhciResponse;
3500
3501 pub use crate::natural::CqhciInitializeCommandQueueingResponse;
3502
3503 pub use crate::natural::SdmmcPerformTuningRequest;
3504
3505 pub use crate::natural::SdmmcRegisterInBandInterruptRequest;
3506
3507 pub use crate::natural::SdmmcRegisterVmoRequest;
3508
3509 pub use crate::natural::SdmmcRequestRequest;
3510
3511 pub use crate::natural::SdmmcSetBusFreqRequest;
3512
3513 pub use crate::natural::SdmmcSetBusWidthRequest;
3514
3515 pub use crate::natural::SdmmcSetSignalVoltageRequest;
3516
3517 pub use crate::natural::SdmmcSetTimingRequest;
3518
3519 pub use crate::natural::SdmmcUnregisterVmoRequest;
3520
3521 pub use crate::natural::SdmmcHostInfoResponse;
3522
3523 pub use crate::natural::SdmmcHwResetResponse;
3524
3525 pub use crate::natural::SdmmcPerformTuningResponse;
3526
3527 pub use crate::natural::SdmmcRegisterInBandInterruptResponse;
3528
3529 pub use crate::natural::SdmmcRegisterVmoResponse;
3530
3531 pub use crate::natural::SdmmcRequestResponse;
3532
3533 pub use crate::natural::SdmmcSetBusFreqResponse;
3534
3535 pub use crate::natural::SdmmcSetBusWidthResponse;
3536
3537 pub use crate::natural::SdmmcSetSignalVoltageResponse;
3538
3539 pub use crate::natural::SdmmcSetTimingResponse;
3540
3541 pub use crate::natural::SdmmcUnregisterVmoResponse;
3542 }
3543
3544 pub struct InitializeCommandQueueing;
3545
3546 impl ::fidl_next::Method for InitializeCommandQueueing {
3547 const ORDINAL: u64 = 359559202570093266;
3548 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3549 ::fidl_next::protocol::Flexibility::Strict;
3550
3551 type Protocol = crate::Sdmmc;
3552
3553 type Request = crate::wire::CqhciInitializeCommandQueueingRequest;
3554 }
3555
3556 impl ::fidl_next::TwoWayMethod for InitializeCommandQueueing {
3557 type Response = ::fidl_next::wire::Result<
3558 'static,
3559 crate::wire::CqhciInitializeCommandQueueingResponse,
3560 ::fidl_next::wire::fuchsia::Status,
3561 >;
3562 }
3563
3564 impl<___R> ::fidl_next::Respond<___R> for InitializeCommandQueueing {
3565 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3566
3567 fn respond(response: ___R) -> Self::Output {
3568 ::core::result::Result::Ok(response)
3569 }
3570 }
3571
3572 impl<___R> ::fidl_next::RespondErr<___R> for InitializeCommandQueueing {
3573 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3574
3575 fn respond_err(response: ___R) -> Self::Output {
3576 ::core::result::Result::Err(response)
3577 }
3578 }
3579
3580 pub struct EnableCqhci;
3581
3582 impl ::fidl_next::Method for EnableCqhci {
3583 const ORDINAL: u64 = 7267012061448928954;
3584 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3585 ::fidl_next::protocol::Flexibility::Strict;
3586
3587 type Protocol = crate::Sdmmc;
3588
3589 type Request = ::fidl_next::wire::EmptyMessageBody;
3590 }
3591
3592 impl ::fidl_next::TwoWayMethod for EnableCqhci {
3593 type Response = ::fidl_next::wire::Result<
3594 'static,
3595 crate::wire::CqhciEnableCqhciResponse,
3596 ::fidl_next::wire::fuchsia::Status,
3597 >;
3598 }
3599
3600 impl<___R> ::fidl_next::Respond<___R> for EnableCqhci {
3601 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3602
3603 fn respond(response: ___R) -> Self::Output {
3604 ::core::result::Result::Ok(response)
3605 }
3606 }
3607
3608 impl<___R> ::fidl_next::RespondErr<___R> for EnableCqhci {
3609 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3610
3611 fn respond_err(response: ___R) -> Self::Output {
3612 ::core::result::Result::Err(response)
3613 }
3614 }
3615
3616 pub struct DisableCqhci;
3617
3618 impl ::fidl_next::Method for DisableCqhci {
3619 const ORDINAL: u64 = 4177196635683073751;
3620 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3621 ::fidl_next::protocol::Flexibility::Strict;
3622
3623 type Protocol = crate::Sdmmc;
3624
3625 type Request = ::fidl_next::wire::EmptyMessageBody;
3626 }
3627
3628 impl ::fidl_next::TwoWayMethod for DisableCqhci {
3629 type Response = ::fidl_next::wire::Result<
3630 'static,
3631 crate::wire::CqhciDisableCqhciResponse,
3632 ::fidl_next::wire::fuchsia::Status,
3633 >;
3634 }
3635
3636 impl<___R> ::fidl_next::Respond<___R> for DisableCqhci {
3637 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3638
3639 fn respond(response: ___R) -> Self::Output {
3640 ::core::result::Result::Ok(response)
3641 }
3642 }
3643
3644 impl<___R> ::fidl_next::RespondErr<___R> for DisableCqhci {
3645 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3646
3647 fn respond_err(response: ___R) -> Self::Output {
3648 ::core::result::Result::Err(response)
3649 }
3650 }
3651
3652 pub struct HostInfo;
3653
3654 impl ::fidl_next::Method for HostInfo {
3655 const ORDINAL: u64 = 8475471856809867100;
3656 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3657 ::fidl_next::protocol::Flexibility::Strict;
3658
3659 type Protocol = crate::Sdmmc;
3660
3661 type Request = ::fidl_next::wire::EmptyMessageBody;
3662 }
3663
3664 impl ::fidl_next::TwoWayMethod for HostInfo {
3665 type Response = ::fidl_next::wire::Result<
3666 'static,
3667 crate::wire::SdmmcHostInfoResponse,
3668 ::fidl_next::wire::fuchsia::Status,
3669 >;
3670 }
3671
3672 impl<___R> ::fidl_next::Respond<___R> for HostInfo {
3673 type Output = ::core::result::Result<
3674 crate::generic::SdmmcHostInfoResponse<___R>,
3675 ::fidl_next::never::Never,
3676 >;
3677
3678 fn respond(response: ___R) -> Self::Output {
3679 ::core::result::Result::Ok(crate::generic::SdmmcHostInfoResponse { info: response })
3680 }
3681 }
3682
3683 impl<___R> ::fidl_next::RespondErr<___R> for HostInfo {
3684 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3685
3686 fn respond_err(response: ___R) -> Self::Output {
3687 ::core::result::Result::Err(response)
3688 }
3689 }
3690
3691 pub struct SetSignalVoltage;
3692
3693 impl ::fidl_next::Method for SetSignalVoltage {
3694 const ORDINAL: u64 = 5360485811549546918;
3695 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3696 ::fidl_next::protocol::Flexibility::Strict;
3697
3698 type Protocol = crate::Sdmmc;
3699
3700 type Request = crate::wire::SdmmcSetSignalVoltageRequest;
3701 }
3702
3703 impl ::fidl_next::TwoWayMethod for SetSignalVoltage {
3704 type Response = ::fidl_next::wire::Result<
3705 'static,
3706 crate::wire::SdmmcSetSignalVoltageResponse,
3707 ::fidl_next::wire::fuchsia::Status,
3708 >;
3709 }
3710
3711 impl<___R> ::fidl_next::Respond<___R> for SetSignalVoltage {
3712 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3713
3714 fn respond(response: ___R) -> Self::Output {
3715 ::core::result::Result::Ok(response)
3716 }
3717 }
3718
3719 impl<___R> ::fidl_next::RespondErr<___R> for SetSignalVoltage {
3720 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3721
3722 fn respond_err(response: ___R) -> Self::Output {
3723 ::core::result::Result::Err(response)
3724 }
3725 }
3726
3727 pub struct SetBusWidth;
3728
3729 impl ::fidl_next::Method for SetBusWidth {
3730 const ORDINAL: u64 = 3438431046250338573;
3731 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3732 ::fidl_next::protocol::Flexibility::Strict;
3733
3734 type Protocol = crate::Sdmmc;
3735
3736 type Request = crate::wire::SdmmcSetBusWidthRequest;
3737 }
3738
3739 impl ::fidl_next::TwoWayMethod for SetBusWidth {
3740 type Response = ::fidl_next::wire::Result<
3741 'static,
3742 crate::wire::SdmmcSetBusWidthResponse,
3743 ::fidl_next::wire::fuchsia::Status,
3744 >;
3745 }
3746
3747 impl<___R> ::fidl_next::Respond<___R> for SetBusWidth {
3748 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3749
3750 fn respond(response: ___R) -> Self::Output {
3751 ::core::result::Result::Ok(response)
3752 }
3753 }
3754
3755 impl<___R> ::fidl_next::RespondErr<___R> for SetBusWidth {
3756 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3757
3758 fn respond_err(response: ___R) -> Self::Output {
3759 ::core::result::Result::Err(response)
3760 }
3761 }
3762
3763 pub struct SetBusFreq;
3764
3765 impl ::fidl_next::Method for SetBusFreq {
3766 const ORDINAL: u64 = 6624771772063616636;
3767 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3768 ::fidl_next::protocol::Flexibility::Strict;
3769
3770 type Protocol = crate::Sdmmc;
3771
3772 type Request = crate::wire::SdmmcSetBusFreqRequest;
3773 }
3774
3775 impl ::fidl_next::TwoWayMethod for SetBusFreq {
3776 type Response = ::fidl_next::wire::Result<
3777 'static,
3778 crate::wire::SdmmcSetBusFreqResponse,
3779 ::fidl_next::wire::fuchsia::Status,
3780 >;
3781 }
3782
3783 impl<___R> ::fidl_next::Respond<___R> for SetBusFreq {
3784 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3785
3786 fn respond(response: ___R) -> Self::Output {
3787 ::core::result::Result::Ok(response)
3788 }
3789 }
3790
3791 impl<___R> ::fidl_next::RespondErr<___R> for SetBusFreq {
3792 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3793
3794 fn respond_err(response: ___R) -> Self::Output {
3795 ::core::result::Result::Err(response)
3796 }
3797 }
3798
3799 pub struct SetTiming;
3800
3801 impl ::fidl_next::Method for SetTiming {
3802 const ORDINAL: u64 = 7991421876873192632;
3803 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3804 ::fidl_next::protocol::Flexibility::Strict;
3805
3806 type Protocol = crate::Sdmmc;
3807
3808 type Request = crate::wire::SdmmcSetTimingRequest;
3809 }
3810
3811 impl ::fidl_next::TwoWayMethod for SetTiming {
3812 type Response = ::fidl_next::wire::Result<
3813 'static,
3814 crate::wire::SdmmcSetTimingResponse,
3815 ::fidl_next::wire::fuchsia::Status,
3816 >;
3817 }
3818
3819 impl<___R> ::fidl_next::Respond<___R> for SetTiming {
3820 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3821
3822 fn respond(response: ___R) -> Self::Output {
3823 ::core::result::Result::Ok(response)
3824 }
3825 }
3826
3827 impl<___R> ::fidl_next::RespondErr<___R> for SetTiming {
3828 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3829
3830 fn respond_err(response: ___R) -> Self::Output {
3831 ::core::result::Result::Err(response)
3832 }
3833 }
3834
3835 pub struct HwReset;
3836
3837 impl ::fidl_next::Method for HwReset {
3838 const ORDINAL: u64 = 3335326454881665312;
3839 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3840 ::fidl_next::protocol::Flexibility::Strict;
3841
3842 type Protocol = crate::Sdmmc;
3843
3844 type Request = ::fidl_next::wire::EmptyMessageBody;
3845 }
3846
3847 impl ::fidl_next::TwoWayMethod for HwReset {
3848 type Response = ::fidl_next::wire::Result<
3849 'static,
3850 crate::wire::SdmmcHwResetResponse,
3851 ::fidl_next::wire::fuchsia::Status,
3852 >;
3853 }
3854
3855 impl<___R> ::fidl_next::Respond<___R> for HwReset {
3856 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3857
3858 fn respond(response: ___R) -> Self::Output {
3859 ::core::result::Result::Ok(response)
3860 }
3861 }
3862
3863 impl<___R> ::fidl_next::RespondErr<___R> for HwReset {
3864 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3865
3866 fn respond_err(response: ___R) -> Self::Output {
3867 ::core::result::Result::Err(response)
3868 }
3869 }
3870
3871 pub struct PerformTuning;
3872
3873 impl ::fidl_next::Method for PerformTuning {
3874 const ORDINAL: u64 = 5267400993243262226;
3875 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3876 ::fidl_next::protocol::Flexibility::Strict;
3877
3878 type Protocol = crate::Sdmmc;
3879
3880 type Request = crate::wire::SdmmcPerformTuningRequest;
3881 }
3882
3883 impl ::fidl_next::TwoWayMethod for PerformTuning {
3884 type Response = ::fidl_next::wire::Result<
3885 'static,
3886 crate::wire::SdmmcPerformTuningResponse,
3887 ::fidl_next::wire::fuchsia::Status,
3888 >;
3889 }
3890
3891 impl<___R> ::fidl_next::Respond<___R> for PerformTuning {
3892 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3893
3894 fn respond(response: ___R) -> Self::Output {
3895 ::core::result::Result::Ok(response)
3896 }
3897 }
3898
3899 impl<___R> ::fidl_next::RespondErr<___R> for PerformTuning {
3900 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3901
3902 fn respond_err(response: ___R) -> Self::Output {
3903 ::core::result::Result::Err(response)
3904 }
3905 }
3906
3907 pub struct RegisterInBandInterrupt;
3908
3909 impl ::fidl_next::Method for RegisterInBandInterrupt {
3910 const ORDINAL: u64 = 7280830926204192948;
3911 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3912 ::fidl_next::protocol::Flexibility::Strict;
3913
3914 type Protocol = crate::Sdmmc;
3915
3916 type Request = crate::wire::SdmmcRegisterInBandInterruptRequest;
3917 }
3918
3919 impl ::fidl_next::TwoWayMethod for RegisterInBandInterrupt {
3920 type Response = ::fidl_next::wire::Result<
3921 'static,
3922 crate::wire::SdmmcRegisterInBandInterruptResponse,
3923 ::fidl_next::wire::fuchsia::Status,
3924 >;
3925 }
3926
3927 impl<___R> ::fidl_next::Respond<___R> for RegisterInBandInterrupt {
3928 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3929
3930 fn respond(response: ___R) -> Self::Output {
3931 ::core::result::Result::Ok(response)
3932 }
3933 }
3934
3935 impl<___R> ::fidl_next::RespondErr<___R> for RegisterInBandInterrupt {
3936 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3937
3938 fn respond_err(response: ___R) -> Self::Output {
3939 ::core::result::Result::Err(response)
3940 }
3941 }
3942
3943 pub struct AckInBandInterrupt;
3944
3945 impl ::fidl_next::Method for AckInBandInterrupt {
3946 const ORDINAL: u64 = 6808342210488695055;
3947 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3948 ::fidl_next::protocol::Flexibility::Strict;
3949
3950 type Protocol = crate::Sdmmc;
3951
3952 type Request = ::fidl_next::wire::EmptyMessageBody;
3953 }
3954
3955 pub struct RegisterVmo;
3956
3957 impl ::fidl_next::Method for RegisterVmo {
3958 const ORDINAL: u64 = 1214620982318353152;
3959 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3960 ::fidl_next::protocol::Flexibility::Strict;
3961
3962 type Protocol = crate::Sdmmc;
3963
3964 type Request = crate::wire::SdmmcRegisterVmoRequest;
3965 }
3966
3967 impl ::fidl_next::TwoWayMethod for RegisterVmo {
3968 type Response = ::fidl_next::wire::Result<
3969 'static,
3970 crate::wire::SdmmcRegisterVmoResponse,
3971 ::fidl_next::wire::fuchsia::Status,
3972 >;
3973 }
3974
3975 impl<___R> ::fidl_next::Respond<___R> for RegisterVmo {
3976 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
3977
3978 fn respond(response: ___R) -> Self::Output {
3979 ::core::result::Result::Ok(response)
3980 }
3981 }
3982
3983 impl<___R> ::fidl_next::RespondErr<___R> for RegisterVmo {
3984 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3985
3986 fn respond_err(response: ___R) -> Self::Output {
3987 ::core::result::Result::Err(response)
3988 }
3989 }
3990
3991 pub struct UnregisterVmo;
3992
3993 impl ::fidl_next::Method for UnregisterVmo {
3994 const ORDINAL: u64 = 8712572721256898471;
3995 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3996 ::fidl_next::protocol::Flexibility::Strict;
3997
3998 type Protocol = crate::Sdmmc;
3999
4000 type Request = crate::wire::SdmmcUnregisterVmoRequest;
4001 }
4002
4003 impl ::fidl_next::TwoWayMethod for UnregisterVmo {
4004 type Response = ::fidl_next::wire::Result<
4005 'static,
4006 crate::wire::SdmmcUnregisterVmoResponse,
4007 ::fidl_next::wire::fuchsia::Status,
4008 >;
4009 }
4010
4011 impl<___R> ::fidl_next::Respond<___R> for UnregisterVmo {
4012 type Output = ::core::result::Result<
4013 crate::generic::SdmmcUnregisterVmoResponse<___R>,
4014 ::fidl_next::never::Never,
4015 >;
4016
4017 fn respond(response: ___R) -> Self::Output {
4018 ::core::result::Result::Ok(crate::generic::SdmmcUnregisterVmoResponse { vmo: response })
4019 }
4020 }
4021
4022 impl<___R> ::fidl_next::RespondErr<___R> for UnregisterVmo {
4023 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
4024
4025 fn respond_err(response: ___R) -> Self::Output {
4026 ::core::result::Result::Err(response)
4027 }
4028 }
4029
4030 pub struct Request;
4031
4032 impl ::fidl_next::Method for Request {
4033 const ORDINAL: u64 = 2766657126441407958;
4034 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4035 ::fidl_next::protocol::Flexibility::Strict;
4036
4037 type Protocol = crate::Sdmmc;
4038
4039 type Request = crate::wire::SdmmcRequestRequest<'static>;
4040 }
4041
4042 impl ::fidl_next::TwoWayMethod for Request {
4043 type Response = ::fidl_next::wire::Result<
4044 'static,
4045 crate::wire::SdmmcRequestResponse,
4046 ::fidl_next::wire::fuchsia::Status,
4047 >;
4048 }
4049
4050 impl<___R> ::fidl_next::Respond<___R> for Request {
4051 type Output = ::core::result::Result<
4052 crate::generic::SdmmcRequestResponse<___R>,
4053 ::fidl_next::never::Never,
4054 >;
4055
4056 fn respond(response: ___R) -> Self::Output {
4057 ::core::result::Result::Ok(crate::generic::SdmmcRequestResponse { response: response })
4058 }
4059 }
4060
4061 impl<___R> ::fidl_next::RespondErr<___R> for Request {
4062 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
4063
4064 fn respond_err(response: ___R) -> Self::Output {
4065 ::core::result::Result::Err(response)
4066 }
4067 }
4068
4069 mod ___detail {
4070 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Sdmmc
4071 where
4072 ___T: ::fidl_next::Transport,
4073 {
4074 type Client = SdmmcClient<___T>;
4075 type Server = SdmmcServer<___T>;
4076 }
4077
4078 #[repr(transparent)]
4080 pub struct SdmmcClient<___T: ::fidl_next::Transport> {
4081 #[allow(dead_code)]
4082 client: ::fidl_next::protocol::Client<___T>,
4083 }
4084
4085 impl<___T> SdmmcClient<___T>
4086 where
4087 ___T: ::fidl_next::Transport,
4088 {
4089 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
4090 pub fn initialize_command_queueing(
4091 &self,
4092
4093 virtual_interrupt: impl ::fidl_next::Encode<
4094 ::fidl_next::wire::fuchsia::Interrupt,
4095 <___T as ::fidl_next::Transport>::SendBuffer,
4096 >,
4097
4098 virtual_interrupt_lifeline: impl ::fidl_next::Encode<
4099 ::fidl_next::wire::fuchsia::EventPair,
4100 <___T as ::fidl_next::Transport>::SendBuffer,
4101 >,
4102 ) -> ::fidl_next::TwoWayFuture<'_, super::InitializeCommandQueueing, ___T>
4103 where
4104 <___T as ::fidl_next::Transport>::SendBuffer:
4105 ::fidl_next::encoder::InternalHandleEncoder,
4106 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4107 {
4108 self.initialize_command_queueing_with(
4109 crate::generic::CqhciInitializeCommandQueueingRequest {
4110 virtual_interrupt,
4111
4112 virtual_interrupt_lifeline,
4113 },
4114 )
4115 }
4116
4117 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
4118 pub fn initialize_command_queueing_with<___R>(
4119 &self,
4120 request: ___R,
4121 ) -> ::fidl_next::TwoWayFuture<'_, super::InitializeCommandQueueing, ___T>
4122 where
4123 ___R: ::fidl_next::Encode<
4124 crate::wire::CqhciInitializeCommandQueueingRequest,
4125 <___T as ::fidl_next::Transport>::SendBuffer,
4126 >,
4127 {
4128 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4129 359559202570093266,
4130 <super::InitializeCommandQueueing as ::fidl_next::Method>::FLEXIBILITY,
4131 request,
4132 ))
4133 }
4134
4135 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
4136 pub fn enable_cqhci(&self) -> ::fidl_next::TwoWayFuture<'_, super::EnableCqhci, ___T> {
4137 ::fidl_next::TwoWayFuture::from_untyped(
4138 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4139 7267012061448928954,
4140 <super::EnableCqhci as ::fidl_next::Method>::FLEXIBILITY,
4141 (),
4142 ),
4143 )
4144 }
4145
4146 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
4147 pub fn disable_cqhci(
4148 &self,
4149 ) -> ::fidl_next::TwoWayFuture<'_, super::DisableCqhci, ___T> {
4150 ::fidl_next::TwoWayFuture::from_untyped(
4151 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4152 4177196635683073751,
4153 <super::DisableCqhci as ::fidl_next::Method>::FLEXIBILITY,
4154 (),
4155 ),
4156 )
4157 }
4158
4159 #[doc = " Get host info.\n"]
4160 pub fn host_info(&self) -> ::fidl_next::TwoWayFuture<'_, super::HostInfo, ___T> {
4161 ::fidl_next::TwoWayFuture::from_untyped(
4162 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4163 8475471856809867100,
4164 <super::HostInfo as ::fidl_next::Method>::FLEXIBILITY,
4165 (),
4166 ),
4167 )
4168 }
4169
4170 #[doc = " Set signal voltage.\n"]
4171 pub fn set_signal_voltage(
4172 &self,
4173
4174 voltage: impl ::fidl_next::Encode<
4175 crate::wire::SdmmcVoltage,
4176 <___T as ::fidl_next::Transport>::SendBuffer,
4177 >,
4178 ) -> ::fidl_next::TwoWayFuture<'_, super::SetSignalVoltage, ___T>
4179 where
4180 <___T as ::fidl_next::Transport>::SendBuffer:
4181 ::fidl_next::encoder::InternalHandleEncoder,
4182 {
4183 self.set_signal_voltage_with(crate::generic::SdmmcSetSignalVoltageRequest {
4184 voltage,
4185 })
4186 }
4187
4188 #[doc = " Set signal voltage.\n"]
4189 pub fn set_signal_voltage_with<___R>(
4190 &self,
4191 request: ___R,
4192 ) -> ::fidl_next::TwoWayFuture<'_, super::SetSignalVoltage, ___T>
4193 where
4194 ___R: ::fidl_next::Encode<
4195 crate::wire::SdmmcSetSignalVoltageRequest,
4196 <___T as ::fidl_next::Transport>::SendBuffer,
4197 >,
4198 {
4199 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4200 5360485811549546918,
4201 <super::SetSignalVoltage as ::fidl_next::Method>::FLEXIBILITY,
4202 request,
4203 ))
4204 }
4205
4206 #[doc = " Set bus width.\n"]
4207 pub fn set_bus_width(
4208 &self,
4209
4210 bus_width: impl ::fidl_next::Encode<
4211 crate::wire::SdmmcBusWidth,
4212 <___T as ::fidl_next::Transport>::SendBuffer,
4213 >,
4214 ) -> ::fidl_next::TwoWayFuture<'_, super::SetBusWidth, ___T>
4215 where
4216 <___T as ::fidl_next::Transport>::SendBuffer:
4217 ::fidl_next::encoder::InternalHandleEncoder,
4218 {
4219 self.set_bus_width_with(crate::generic::SdmmcSetBusWidthRequest { bus_width })
4220 }
4221
4222 #[doc = " Set bus width.\n"]
4223 pub fn set_bus_width_with<___R>(
4224 &self,
4225 request: ___R,
4226 ) -> ::fidl_next::TwoWayFuture<'_, super::SetBusWidth, ___T>
4227 where
4228 ___R: ::fidl_next::Encode<
4229 crate::wire::SdmmcSetBusWidthRequest,
4230 <___T as ::fidl_next::Transport>::SendBuffer,
4231 >,
4232 {
4233 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4234 3438431046250338573,
4235 <super::SetBusWidth as ::fidl_next::Method>::FLEXIBILITY,
4236 request,
4237 ))
4238 }
4239
4240 #[doc = " Set bus frequency, zero means disable the clock to the card.\n"]
4241 pub fn set_bus_freq(
4242 &self,
4243
4244 bus_freq: impl ::fidl_next::Encode<
4245 ::fidl_next::wire::Uint32,
4246 <___T as ::fidl_next::Transport>::SendBuffer,
4247 >,
4248 ) -> ::fidl_next::TwoWayFuture<'_, super::SetBusFreq, ___T>
4249 where
4250 <___T as ::fidl_next::Transport>::SendBuffer:
4251 ::fidl_next::encoder::InternalHandleEncoder,
4252 {
4253 self.set_bus_freq_with(crate::generic::SdmmcSetBusFreqRequest { bus_freq })
4254 }
4255
4256 #[doc = " Set bus frequency, zero means disable the clock to the card.\n"]
4257 pub fn set_bus_freq_with<___R>(
4258 &self,
4259 request: ___R,
4260 ) -> ::fidl_next::TwoWayFuture<'_, super::SetBusFreq, ___T>
4261 where
4262 ___R: ::fidl_next::Encode<
4263 crate::wire::SdmmcSetBusFreqRequest,
4264 <___T as ::fidl_next::Transport>::SendBuffer,
4265 >,
4266 {
4267 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4268 6624771772063616636,
4269 <super::SetBusFreq as ::fidl_next::Method>::FLEXIBILITY,
4270 request,
4271 ))
4272 }
4273
4274 #[doc = " Set mmc timing.\n"]
4275 pub fn set_timing(
4276 &self,
4277
4278 timing: impl ::fidl_next::Encode<
4279 crate::wire::SdmmcTiming,
4280 <___T as ::fidl_next::Transport>::SendBuffer,
4281 >,
4282 ) -> ::fidl_next::TwoWayFuture<'_, super::SetTiming, ___T>
4283 where
4284 <___T as ::fidl_next::Transport>::SendBuffer:
4285 ::fidl_next::encoder::InternalHandleEncoder,
4286 {
4287 self.set_timing_with(crate::generic::SdmmcSetTimingRequest { timing })
4288 }
4289
4290 #[doc = " Set mmc timing.\n"]
4291 pub fn set_timing_with<___R>(
4292 &self,
4293 request: ___R,
4294 ) -> ::fidl_next::TwoWayFuture<'_, super::SetTiming, ___T>
4295 where
4296 ___R: ::fidl_next::Encode<
4297 crate::wire::SdmmcSetTimingRequest,
4298 <___T as ::fidl_next::Transport>::SendBuffer,
4299 >,
4300 {
4301 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4302 7991421876873192632,
4303 <super::SetTiming as ::fidl_next::Method>::FLEXIBILITY,
4304 request,
4305 ))
4306 }
4307
4308 #[doc = " Issue a hw reset.\n"]
4309 pub fn hw_reset(&self) -> ::fidl_next::TwoWayFuture<'_, super::HwReset, ___T> {
4310 ::fidl_next::TwoWayFuture::from_untyped(
4311 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4312 3335326454881665312,
4313 <super::HwReset as ::fidl_next::Method>::FLEXIBILITY,
4314 (),
4315 ),
4316 )
4317 }
4318
4319 #[doc = " Perform tuning.\n"]
4320 pub fn perform_tuning(
4321 &self,
4322
4323 cmd_idx: impl ::fidl_next::Encode<
4324 ::fidl_next::wire::Uint32,
4325 <___T as ::fidl_next::Transport>::SendBuffer,
4326 >,
4327 ) -> ::fidl_next::TwoWayFuture<'_, super::PerformTuning, ___T>
4328 where
4329 <___T as ::fidl_next::Transport>::SendBuffer:
4330 ::fidl_next::encoder::InternalHandleEncoder,
4331 {
4332 self.perform_tuning_with(crate::generic::SdmmcPerformTuningRequest { cmd_idx })
4333 }
4334
4335 #[doc = " Perform tuning.\n"]
4336 pub fn perform_tuning_with<___R>(
4337 &self,
4338 request: ___R,
4339 ) -> ::fidl_next::TwoWayFuture<'_, super::PerformTuning, ___T>
4340 where
4341 ___R: ::fidl_next::Encode<
4342 crate::wire::SdmmcPerformTuningRequest,
4343 <___T as ::fidl_next::Transport>::SendBuffer,
4344 >,
4345 {
4346 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4347 5267400993243262226,
4348 <super::PerformTuning as ::fidl_next::Method>::FLEXIBILITY,
4349 request,
4350 ))
4351 }
4352
4353 #[doc = " Register the given callback to be called when an in-band interrupt is received from the\n card. Before calling the callback the protocol implementation will disable the in-band\n interrupt in the controller. In-band interrupts can be re-enabled by calling\n `AckInBandInterrupt()` once the previous interrupt has been handled by the client.\n"]
4354 pub fn register_in_band_interrupt(
4355 &self,
4356
4357 interrupt_cb: impl ::fidl_next::Encode<
4358 ::fidl_next::ClientEnd<crate::InBandInterrupt, ::fdf_fidl::wire::DriverChannel>,
4359 <___T as ::fidl_next::Transport>::SendBuffer,
4360 >,
4361 ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterInBandInterrupt, ___T>
4362 where
4363 <___T as ::fidl_next::Transport>::SendBuffer:
4364 ::fidl_next::encoder::InternalHandleEncoder,
4365 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4366 {
4367 self.register_in_band_interrupt_with(
4368 crate::generic::SdmmcRegisterInBandInterruptRequest { interrupt_cb },
4369 )
4370 }
4371
4372 #[doc = " Register the given callback to be called when an in-band interrupt is received from the\n card. Before calling the callback the protocol implementation will disable the in-band\n interrupt in the controller. In-band interrupts can be re-enabled by calling\n `AckInBandInterrupt()` once the previous interrupt has been handled by the client.\n"]
4373 pub fn register_in_band_interrupt_with<___R>(
4374 &self,
4375 request: ___R,
4376 ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterInBandInterrupt, ___T>
4377 where
4378 ___R: ::fidl_next::Encode<
4379 crate::wire::SdmmcRegisterInBandInterruptRequest,
4380 <___T as ::fidl_next::Transport>::SendBuffer,
4381 >,
4382 {
4383 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4384 7280830926204192948,
4385 <super::RegisterInBandInterrupt as ::fidl_next::Method>::FLEXIBILITY,
4386 request,
4387 ))
4388 }
4389
4390 pub fn ack_in_band_interrupt(&self) -> ::fidl_next::SendFuture<'_, ___T> {
4391 ::fidl_next::SendFuture::from_untyped(
4392 self.client.send_one_way::<::fidl_next::wire::EmptyMessageBody>(
4393 6808342210488695055,
4394 <super::AckInBandInterrupt as ::fidl_next::Method>::FLEXIBILITY,
4395 (),
4396 ),
4397 )
4398 }
4399
4400 #[doc = " In the methods below, vmo_id is used to uniquely identify a VMO that will be passed to\n Request in an SdmmcBufferRegion. VMO IDs are chosen by the caller, and may be any uint32\n value.\n Registers a VMO and transfers ownership to the protocol implementation. vmo_rights is a bit\n field containing SdmmcVmoRight values, and determines the read/write permissions used by\n the implementation when pinning or mapping the VMO. The implementation may pin vmo during\n this call or any time it is used in a request, and may keep it pinned until the VMO is\n unregistered. client_id may be in [0, SDMMC_MAX_CLIENT_ID] and identifies the ID space for\n this VMO to be registered in (that is, two different VMOs may use the same ID if they are\n registered for different clients).\n"]
4401 pub fn register_vmo(
4402 &self,
4403
4404 vmo_id: impl ::fidl_next::Encode<
4405 ::fidl_next::wire::Uint32,
4406 <___T as ::fidl_next::Transport>::SendBuffer,
4407 >,
4408
4409 client_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
4410
4411 vmo: impl ::fidl_next::Encode<
4412 ::fidl_next::wire::fuchsia::Vmo,
4413 <___T as ::fidl_next::Transport>::SendBuffer,
4414 >,
4415
4416 offset: impl ::fidl_next::Encode<
4417 ::fidl_next::wire::Uint64,
4418 <___T as ::fidl_next::Transport>::SendBuffer,
4419 >,
4420
4421 size: impl ::fidl_next::Encode<
4422 ::fidl_next::wire::Uint64,
4423 <___T as ::fidl_next::Transport>::SendBuffer,
4424 >,
4425
4426 vmo_rights: impl ::fidl_next::Encode<
4427 crate::wire::SdmmcVmoRight,
4428 <___T as ::fidl_next::Transport>::SendBuffer,
4429 >,
4430 ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
4431 where
4432 <___T as ::fidl_next::Transport>::SendBuffer:
4433 ::fidl_next::encoder::InternalHandleEncoder,
4434 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4435 {
4436 self.register_vmo_with(crate::generic::SdmmcRegisterVmoRequest {
4437 vmo_id,
4438
4439 client_id,
4440
4441 vmo,
4442
4443 offset,
4444
4445 size,
4446
4447 vmo_rights,
4448 })
4449 }
4450
4451 #[doc = " In the methods below, vmo_id is used to uniquely identify a VMO that will be passed to\n Request in an SdmmcBufferRegion. VMO IDs are chosen by the caller, and may be any uint32\n value.\n Registers a VMO and transfers ownership to the protocol implementation. vmo_rights is a bit\n field containing SdmmcVmoRight values, and determines the read/write permissions used by\n the implementation when pinning or mapping the VMO. The implementation may pin vmo during\n this call or any time it is used in a request, and may keep it pinned until the VMO is\n unregistered. client_id may be in [0, SDMMC_MAX_CLIENT_ID] and identifies the ID space for\n this VMO to be registered in (that is, two different VMOs may use the same ID if they are\n registered for different clients).\n"]
4452 pub fn register_vmo_with<___R>(
4453 &self,
4454 request: ___R,
4455 ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
4456 where
4457 ___R: ::fidl_next::Encode<
4458 crate::wire::SdmmcRegisterVmoRequest,
4459 <___T as ::fidl_next::Transport>::SendBuffer,
4460 >,
4461 {
4462 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4463 1214620982318353152,
4464 <super::RegisterVmo as ::fidl_next::Method>::FLEXIBILITY,
4465 request,
4466 ))
4467 }
4468
4469 #[doc = " The callee unmaps/unpins the VMO and returns ownership to the caller.\n"]
4470 pub fn unregister_vmo(
4471 &self,
4472
4473 vmo_id: impl ::fidl_next::Encode<
4474 ::fidl_next::wire::Uint32,
4475 <___T as ::fidl_next::Transport>::SendBuffer,
4476 >,
4477
4478 client_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,
4479 ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
4480 where
4481 <___T as ::fidl_next::Transport>::SendBuffer:
4482 ::fidl_next::encoder::InternalHandleEncoder,
4483 {
4484 self.unregister_vmo_with(crate::generic::SdmmcUnregisterVmoRequest {
4485 vmo_id,
4486
4487 client_id,
4488 })
4489 }
4490
4491 #[doc = " The callee unmaps/unpins the VMO and returns ownership to the caller.\n"]
4492 pub fn unregister_vmo_with<___R>(
4493 &self,
4494 request: ___R,
4495 ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
4496 where
4497 ___R: ::fidl_next::Encode<
4498 crate::wire::SdmmcUnregisterVmoRequest,
4499 <___T as ::fidl_next::Transport>::SendBuffer,
4500 >,
4501 {
4502 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4503 8712572721256898471,
4504 <super::UnregisterVmo as ::fidl_next::Method>::FLEXIBILITY,
4505 request,
4506 ))
4507 }
4508
4509 #[doc = " Perform the requests in order, atomically (i.e., no intervening requests). Furthermore,\n calls are replied to in the order they are received. If an error occurs, abort any remaining\n requests. Else, return the response of the last request.\n\n The protocol implementation chooses whether or not to use DMA\n depending on the properties of the request and the capabilities of the controller.\n\n Clients are responsible for performing the following cache operations:\n\n After read requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE on buffers that\n have been mapped by the client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN_INVALIDATE on all other buffers.\n\n Note that writing to any portion of a buffer before Request has returned can corrupt the\n received data.\n\n Before write requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA on buffers that have been mapped by the\n client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN on all other buffers.\n"]
4510 pub fn request(
4511 &self,
4512
4513 reqs: impl ::fidl_next::Encode<
4514 ::fidl_next::wire::Vector<'static, crate::wire::SdmmcReq<'static>>,
4515 <___T as ::fidl_next::Transport>::SendBuffer,
4516 >,
4517 ) -> ::fidl_next::TwoWayFuture<'_, super::Request, ___T>
4518 where
4519 <___T as ::fidl_next::Transport>::SendBuffer:
4520 ::fidl_next::encoder::InternalHandleEncoder,
4521 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4522 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4523 {
4524 self.request_with(crate::generic::SdmmcRequestRequest { reqs })
4525 }
4526
4527 #[doc = " Perform the requests in order, atomically (i.e., no intervening requests). Furthermore,\n calls are replied to in the order they are received. If an error occurs, abort any remaining\n requests. Else, return the response of the last request.\n\n The protocol implementation chooses whether or not to use DMA\n depending on the properties of the request and the capabilities of the controller.\n\n Clients are responsible for performing the following cache operations:\n\n After read requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE on buffers that\n have been mapped by the client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN_INVALIDATE on all other buffers.\n\n Note that writing to any portion of a buffer before Request has returned can corrupt the\n received data.\n\n Before write requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA on buffers that have been mapped by the\n client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN on all other buffers.\n"]
4528 pub fn request_with<___R>(
4529 &self,
4530 request: ___R,
4531 ) -> ::fidl_next::TwoWayFuture<'_, super::Request, ___T>
4532 where
4533 ___R: ::fidl_next::Encode<
4534 crate::wire::SdmmcRequestRequest<'static>,
4535 <___T as ::fidl_next::Transport>::SendBuffer,
4536 >,
4537 {
4538 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4539 2766657126441407958,
4540 <super::Request as ::fidl_next::Method>::FLEXIBILITY,
4541 request,
4542 ))
4543 }
4544 }
4545
4546 #[repr(transparent)]
4548 pub struct SdmmcServer<___T: ::fidl_next::Transport> {
4549 server: ::fidl_next::protocol::Server<___T>,
4550 }
4551
4552 impl<___T> SdmmcServer<___T> where ___T: ::fidl_next::Transport {}
4553 }
4554}
4555
4556#[diagnostic::on_unimplemented(
4557 note = "If {Self} implements the non-local SdmmcClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4558)]
4559
4560pub trait SdmmcLocalClientHandler<
4564 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
4565 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
4566>
4567{
4568}
4569
4570impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Sdmmc
4571where
4572 ___H: SdmmcLocalClientHandler<___T>,
4573 ___T: ::fidl_next::Transport,
4574{
4575 async fn on_event(
4576 handler: &mut ___H,
4577 mut message: ::fidl_next::Message<___T>,
4578 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4579 match *message.header().ordinal {
4580 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4581 }
4582 }
4583}
4584
4585#[diagnostic::on_unimplemented(
4586 note = "If {Self} implements the non-local SdmmcServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4587)]
4588
4589pub trait SdmmcLocalServerHandler<
4593 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
4594 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
4595>
4596{
4597 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
4598 fn initialize_command_queueing(
4599 &mut self,
4600
4601 request: ::fidl_next::Request<sdmmc::InitializeCommandQueueing, ___T>,
4602
4603 responder: ::fidl_next::Responder<sdmmc::InitializeCommandQueueing, ___T>,
4604 ) -> impl ::core::future::Future<Output = ()>;
4605
4606 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
4607 fn enable_cqhci(
4608 &mut self,
4609
4610 responder: ::fidl_next::Responder<sdmmc::EnableCqhci, ___T>,
4611 ) -> impl ::core::future::Future<Output = ()>;
4612
4613 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
4614 fn disable_cqhci(
4615 &mut self,
4616
4617 responder: ::fidl_next::Responder<sdmmc::DisableCqhci, ___T>,
4618 ) -> impl ::core::future::Future<Output = ()>;
4619
4620 #[doc = " Get host info.\n"]
4621 fn host_info(
4622 &mut self,
4623
4624 responder: ::fidl_next::Responder<sdmmc::HostInfo, ___T>,
4625 ) -> impl ::core::future::Future<Output = ()>;
4626
4627 #[doc = " Set signal voltage.\n"]
4628 fn set_signal_voltage(
4629 &mut self,
4630
4631 request: ::fidl_next::Request<sdmmc::SetSignalVoltage, ___T>,
4632
4633 responder: ::fidl_next::Responder<sdmmc::SetSignalVoltage, ___T>,
4634 ) -> impl ::core::future::Future<Output = ()>;
4635
4636 #[doc = " Set bus width.\n"]
4637 fn set_bus_width(
4638 &mut self,
4639
4640 request: ::fidl_next::Request<sdmmc::SetBusWidth, ___T>,
4641
4642 responder: ::fidl_next::Responder<sdmmc::SetBusWidth, ___T>,
4643 ) -> impl ::core::future::Future<Output = ()>;
4644
4645 #[doc = " Set bus frequency, zero means disable the clock to the card.\n"]
4646 fn set_bus_freq(
4647 &mut self,
4648
4649 request: ::fidl_next::Request<sdmmc::SetBusFreq, ___T>,
4650
4651 responder: ::fidl_next::Responder<sdmmc::SetBusFreq, ___T>,
4652 ) -> impl ::core::future::Future<Output = ()>;
4653
4654 #[doc = " Set mmc timing.\n"]
4655 fn set_timing(
4656 &mut self,
4657
4658 request: ::fidl_next::Request<sdmmc::SetTiming, ___T>,
4659
4660 responder: ::fidl_next::Responder<sdmmc::SetTiming, ___T>,
4661 ) -> impl ::core::future::Future<Output = ()>;
4662
4663 #[doc = " Issue a hw reset.\n"]
4664 fn hw_reset(
4665 &mut self,
4666
4667 responder: ::fidl_next::Responder<sdmmc::HwReset, ___T>,
4668 ) -> impl ::core::future::Future<Output = ()>;
4669
4670 #[doc = " Perform tuning.\n"]
4671 fn perform_tuning(
4672 &mut self,
4673
4674 request: ::fidl_next::Request<sdmmc::PerformTuning, ___T>,
4675
4676 responder: ::fidl_next::Responder<sdmmc::PerformTuning, ___T>,
4677 ) -> impl ::core::future::Future<Output = ()>;
4678
4679 #[doc = " Register the given callback to be called when an in-band interrupt is received from the\n card. Before calling the callback the protocol implementation will disable the in-band\n interrupt in the controller. In-band interrupts can be re-enabled by calling\n `AckInBandInterrupt()` once the previous interrupt has been handled by the client.\n"]
4680 fn register_in_band_interrupt(
4681 &mut self,
4682
4683 request: ::fidl_next::Request<sdmmc::RegisterInBandInterrupt, ___T>,
4684
4685 responder: ::fidl_next::Responder<sdmmc::RegisterInBandInterrupt, ___T>,
4686 ) -> impl ::core::future::Future<Output = ()>;
4687
4688 fn ack_in_band_interrupt(&mut self) -> impl ::core::future::Future<Output = ()>;
4689
4690 #[doc = " In the methods below, vmo_id is used to uniquely identify a VMO that will be passed to\n Request in an SdmmcBufferRegion. VMO IDs are chosen by the caller, and may be any uint32\n value.\n Registers a VMO and transfers ownership to the protocol implementation. vmo_rights is a bit\n field containing SdmmcVmoRight values, and determines the read/write permissions used by\n the implementation when pinning or mapping the VMO. The implementation may pin vmo during\n this call or any time it is used in a request, and may keep it pinned until the VMO is\n unregistered. client_id may be in [0, SDMMC_MAX_CLIENT_ID] and identifies the ID space for\n this VMO to be registered in (that is, two different VMOs may use the same ID if they are\n registered for different clients).\n"]
4691 fn register_vmo(
4692 &mut self,
4693
4694 request: ::fidl_next::Request<sdmmc::RegisterVmo, ___T>,
4695
4696 responder: ::fidl_next::Responder<sdmmc::RegisterVmo, ___T>,
4697 ) -> impl ::core::future::Future<Output = ()>;
4698
4699 #[doc = " The callee unmaps/unpins the VMO and returns ownership to the caller.\n"]
4700 fn unregister_vmo(
4701 &mut self,
4702
4703 request: ::fidl_next::Request<sdmmc::UnregisterVmo, ___T>,
4704
4705 responder: ::fidl_next::Responder<sdmmc::UnregisterVmo, ___T>,
4706 ) -> impl ::core::future::Future<Output = ()>;
4707
4708 #[doc = " Perform the requests in order, atomically (i.e., no intervening requests). Furthermore,\n calls are replied to in the order they are received. If an error occurs, abort any remaining\n requests. Else, return the response of the last request.\n\n The protocol implementation chooses whether or not to use DMA\n depending on the properties of the request and the capabilities of the controller.\n\n Clients are responsible for performing the following cache operations:\n\n After read requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE on buffers that\n have been mapped by the client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN_INVALIDATE on all other buffers.\n\n Note that writing to any portion of a buffer before Request has returned can corrupt the\n received data.\n\n Before write requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA on buffers that have been mapped by the\n client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN on all other buffers.\n"]
4709 fn request(
4710 &mut self,
4711
4712 request: ::fidl_next::Request<sdmmc::Request, ___T>,
4713
4714 responder: ::fidl_next::Responder<sdmmc::Request, ___T>,
4715 ) -> impl ::core::future::Future<Output = ()>;
4716}
4717
4718impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Sdmmc
4719where
4720 ___H: SdmmcLocalServerHandler<___T>,
4721 ___T: ::fidl_next::Transport,
4722 for<'de> crate::wire::CqhciInitializeCommandQueueingRequest: ::fidl_next::Decode<
4723 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4724 Constraint = (),
4725 >,
4726 for<'de> crate::wire::SdmmcSetSignalVoltageRequest: ::fidl_next::Decode<
4727 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4728 Constraint = (),
4729 >,
4730 for<'de> crate::wire::SdmmcSetBusWidthRequest: ::fidl_next::Decode<
4731 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4732 Constraint = (),
4733 >,
4734 for<'de> crate::wire::SdmmcSetBusFreqRequest: ::fidl_next::Decode<
4735 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4736 Constraint = (),
4737 >,
4738 for<'de> crate::wire::SdmmcSetTimingRequest: ::fidl_next::Decode<
4739 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4740 Constraint = (),
4741 >,
4742 for<'de> crate::wire::SdmmcPerformTuningRequest: ::fidl_next::Decode<
4743 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4744 Constraint = (),
4745 >,
4746 for<'de> crate::wire::SdmmcRegisterInBandInterruptRequest: ::fidl_next::Decode<
4747 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4748 Constraint = (),
4749 >,
4750 for<'de> crate::wire::SdmmcRegisterVmoRequest: ::fidl_next::Decode<
4751 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4752 Constraint = (),
4753 >,
4754 for<'de> crate::wire::SdmmcUnregisterVmoRequest: ::fidl_next::Decode<
4755 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4756 Constraint = (),
4757 >,
4758 for<'de> crate::wire::SdmmcRequestRequest<'de>: ::fidl_next::Decode<
4759 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4760 Constraint = (),
4761 >,
4762{
4763 async fn on_one_way(
4764 handler: &mut ___H,
4765 mut message: ::fidl_next::Message<___T>,
4766 ) -> ::core::result::Result<
4767 (),
4768 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4769 > {
4770 match *message.header().ordinal {
4771 6808342210488695055 => {
4772 handler.ack_in_band_interrupt().await;
4773 Ok(())
4774 }
4775
4776 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4777 }
4778 }
4779
4780 async fn on_two_way(
4781 handler: &mut ___H,
4782 mut message: ::fidl_next::Message<___T>,
4783 responder: ::fidl_next::protocol::Responder<___T>,
4784 ) -> ::core::result::Result<
4785 (),
4786 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4787 > {
4788 match *message.header().ordinal {
4789 359559202570093266 => {
4790 let responder = ::fidl_next::Responder::from_untyped(responder);
4791
4792 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4793 Ok(decoded) => {
4794 handler
4795 .initialize_command_queueing(
4796 ::fidl_next::Request::from_decoded(decoded),
4797 responder,
4798 )
4799 .await;
4800 Ok(())
4801 }
4802 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4803 ordinal: 359559202570093266,
4804 error,
4805 }),
4806 }
4807 }
4808
4809 7267012061448928954 => {
4810 let responder = ::fidl_next::Responder::from_untyped(responder);
4811
4812 handler.enable_cqhci(responder).await;
4813 Ok(())
4814 }
4815
4816 4177196635683073751 => {
4817 let responder = ::fidl_next::Responder::from_untyped(responder);
4818
4819 handler.disable_cqhci(responder).await;
4820 Ok(())
4821 }
4822
4823 8475471856809867100 => {
4824 let responder = ::fidl_next::Responder::from_untyped(responder);
4825
4826 handler.host_info(responder).await;
4827 Ok(())
4828 }
4829
4830 5360485811549546918 => {
4831 let responder = ::fidl_next::Responder::from_untyped(responder);
4832
4833 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4834 Ok(decoded) => {
4835 handler
4836 .set_signal_voltage(
4837 ::fidl_next::Request::from_decoded(decoded),
4838 responder,
4839 )
4840 .await;
4841 Ok(())
4842 }
4843 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4844 ordinal: 5360485811549546918,
4845 error,
4846 }),
4847 }
4848 }
4849
4850 3438431046250338573 => {
4851 let responder = ::fidl_next::Responder::from_untyped(responder);
4852
4853 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4854 Ok(decoded) => {
4855 handler
4856 .set_bus_width(::fidl_next::Request::from_decoded(decoded), responder)
4857 .await;
4858 Ok(())
4859 }
4860 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4861 ordinal: 3438431046250338573,
4862 error,
4863 }),
4864 }
4865 }
4866
4867 6624771772063616636 => {
4868 let responder = ::fidl_next::Responder::from_untyped(responder);
4869
4870 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4871 Ok(decoded) => {
4872 handler
4873 .set_bus_freq(::fidl_next::Request::from_decoded(decoded), responder)
4874 .await;
4875 Ok(())
4876 }
4877 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4878 ordinal: 6624771772063616636,
4879 error,
4880 }),
4881 }
4882 }
4883
4884 7991421876873192632 => {
4885 let responder = ::fidl_next::Responder::from_untyped(responder);
4886
4887 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4888 Ok(decoded) => {
4889 handler
4890 .set_timing(::fidl_next::Request::from_decoded(decoded), responder)
4891 .await;
4892 Ok(())
4893 }
4894 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4895 ordinal: 7991421876873192632,
4896 error,
4897 }),
4898 }
4899 }
4900
4901 3335326454881665312 => {
4902 let responder = ::fidl_next::Responder::from_untyped(responder);
4903
4904 handler.hw_reset(responder).await;
4905 Ok(())
4906 }
4907
4908 5267400993243262226 => {
4909 let responder = ::fidl_next::Responder::from_untyped(responder);
4910
4911 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4912 Ok(decoded) => {
4913 handler
4914 .perform_tuning(::fidl_next::Request::from_decoded(decoded), responder)
4915 .await;
4916 Ok(())
4917 }
4918 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4919 ordinal: 5267400993243262226,
4920 error,
4921 }),
4922 }
4923 }
4924
4925 7280830926204192948 => {
4926 let responder = ::fidl_next::Responder::from_untyped(responder);
4927
4928 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4929 Ok(decoded) => {
4930 handler
4931 .register_in_band_interrupt(
4932 ::fidl_next::Request::from_decoded(decoded),
4933 responder,
4934 )
4935 .await;
4936 Ok(())
4937 }
4938 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4939 ordinal: 7280830926204192948,
4940 error,
4941 }),
4942 }
4943 }
4944
4945 1214620982318353152 => {
4946 let responder = ::fidl_next::Responder::from_untyped(responder);
4947
4948 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4949 Ok(decoded) => {
4950 handler
4951 .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
4952 .await;
4953 Ok(())
4954 }
4955 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4956 ordinal: 1214620982318353152,
4957 error,
4958 }),
4959 }
4960 }
4961
4962 8712572721256898471 => {
4963 let responder = ::fidl_next::Responder::from_untyped(responder);
4964
4965 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4966 Ok(decoded) => {
4967 handler
4968 .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
4969 .await;
4970 Ok(())
4971 }
4972 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4973 ordinal: 8712572721256898471,
4974 error,
4975 }),
4976 }
4977 }
4978
4979 2766657126441407958 => {
4980 let responder = ::fidl_next::Responder::from_untyped(responder);
4981
4982 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4983 Ok(decoded) => {
4984 handler
4985 .request(::fidl_next::Request::from_decoded(decoded), responder)
4986 .await;
4987 Ok(())
4988 }
4989 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4990 ordinal: 2766657126441407958,
4991 error,
4992 }),
4993 }
4994 }
4995
4996 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4997 }
4998 }
4999}
5000
5001pub trait SdmmcClientHandler<
5005 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
5006 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
5007>
5008{
5009}
5010
5011impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Sdmmc
5012where
5013 ___H: SdmmcClientHandler<___T> + ::core::marker::Send,
5014 ___T: ::fidl_next::Transport,
5015{
5016 async fn on_event(
5017 handler: &mut ___H,
5018 mut message: ::fidl_next::Message<___T>,
5019 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5020 match *message.header().ordinal {
5021 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5022 }
5023 }
5024}
5025
5026pub trait SdmmcServerHandler<
5030 #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
5031 #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
5032>
5033{
5034 #[doc = " Initializes the CQHCI driver, providing it with all necessary resources.\n\n This call is expected to be made once. The server should reject any additional calls\n until the peer end of `virtual_interrupt_lifeline` closes.\n\n # Interrupt Delegation\n\n While the CQHCI driver is running, it takes over the physical IRQ object from its underlying\n driver, and directly handles any CQHCI-specific interrupts. Interrupts which it cannot\n service (e.g. SDHCI interrupts) are forwarded to the underlying driver via\n `virtual_interrupt`. The server should service interrupts exactly as it normally would.\n The CQHCI driver will wait for the virtual IRQ to be acked before acking the physical IRQ.\n\n # Arguments\n\n * `virtual_interrupt` - A virtual interrupt to monitor instead of the physical IRQ.\n The CQHCI driver will use this to forward interrupts which it cannot directly service.\n * `virtual_interrupt_lifeline` - A lifeline for the virtual interrupt. The CQHCI\n driver will destroy the peer end upon shutdown, which should be handled by the server as a\n signal to stop monitoring the virtual interrupt and return to monitoring the physical\n interrupt.\n\n # Returns\n\n * `cqhci_mmio` and `cqhci_mmio_offset` - An MMIO for the CQHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the CQHCI specification.\n * `sdhci_mmio` and `sdhci_mmio_offset` - An MMIO for the SDHCI register block.\n MMIO size minus offset must be at least 512 bytes as per the SDHCI specification.\n * `bti` - The BTI to use for pinning pages for DMA.\n * `interrupt` - The physical interrupt to monitor.\n"]
5035 fn initialize_command_queueing(
5036 &mut self,
5037
5038 request: ::fidl_next::Request<sdmmc::InitializeCommandQueueing, ___T>,
5039
5040 responder: ::fidl_next::Responder<sdmmc::InitializeCommandQueueing, ___T>,
5041 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5042
5043 #[doc = " Enables the Command Queueing Engine. The CQHCI driver is expected to already have called\n [`InitializeCommandQueueing`] to handle interrupts.\n While CQHCI is enabled, it is the caller\'s responsibility to only submit regular requests\n (via [`Request`]) via DCMD, or after disabling CQHCI.\n"]
5044 fn enable_cqhci(
5045 &mut self,
5046
5047 responder: ::fidl_next::Responder<sdmmc::EnableCqhci, ___T>,
5048 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5049
5050 #[doc = " Disables the Command Queueing Engine. `EnableCqhci` must have previously been called. From\n this point onwards, regular requests can be submitted (until `EnableCqhci` is called again).\n"]
5051 fn disable_cqhci(
5052 &mut self,
5053
5054 responder: ::fidl_next::Responder<sdmmc::DisableCqhci, ___T>,
5055 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5056
5057 #[doc = " Get host info.\n"]
5058 fn host_info(
5059 &mut self,
5060
5061 responder: ::fidl_next::Responder<sdmmc::HostInfo, ___T>,
5062 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5063
5064 #[doc = " Set signal voltage.\n"]
5065 fn set_signal_voltage(
5066 &mut self,
5067
5068 request: ::fidl_next::Request<sdmmc::SetSignalVoltage, ___T>,
5069
5070 responder: ::fidl_next::Responder<sdmmc::SetSignalVoltage, ___T>,
5071 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5072
5073 #[doc = " Set bus width.\n"]
5074 fn set_bus_width(
5075 &mut self,
5076
5077 request: ::fidl_next::Request<sdmmc::SetBusWidth, ___T>,
5078
5079 responder: ::fidl_next::Responder<sdmmc::SetBusWidth, ___T>,
5080 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5081
5082 #[doc = " Set bus frequency, zero means disable the clock to the card.\n"]
5083 fn set_bus_freq(
5084 &mut self,
5085
5086 request: ::fidl_next::Request<sdmmc::SetBusFreq, ___T>,
5087
5088 responder: ::fidl_next::Responder<sdmmc::SetBusFreq, ___T>,
5089 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5090
5091 #[doc = " Set mmc timing.\n"]
5092 fn set_timing(
5093 &mut self,
5094
5095 request: ::fidl_next::Request<sdmmc::SetTiming, ___T>,
5096
5097 responder: ::fidl_next::Responder<sdmmc::SetTiming, ___T>,
5098 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5099
5100 #[doc = " Issue a hw reset.\n"]
5101 fn hw_reset(
5102 &mut self,
5103
5104 responder: ::fidl_next::Responder<sdmmc::HwReset, ___T>,
5105 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5106
5107 #[doc = " Perform tuning.\n"]
5108 fn perform_tuning(
5109 &mut self,
5110
5111 request: ::fidl_next::Request<sdmmc::PerformTuning, ___T>,
5112
5113 responder: ::fidl_next::Responder<sdmmc::PerformTuning, ___T>,
5114 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5115
5116 #[doc = " Register the given callback to be called when an in-band interrupt is received from the\n card. Before calling the callback the protocol implementation will disable the in-band\n interrupt in the controller. In-band interrupts can be re-enabled by calling\n `AckInBandInterrupt()` once the previous interrupt has been handled by the client.\n"]
5117 fn register_in_band_interrupt(
5118 &mut self,
5119
5120 request: ::fidl_next::Request<sdmmc::RegisterInBandInterrupt, ___T>,
5121
5122 responder: ::fidl_next::Responder<sdmmc::RegisterInBandInterrupt, ___T>,
5123 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5124
5125 fn ack_in_band_interrupt(
5126 &mut self,
5127 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5128
5129 #[doc = " In the methods below, vmo_id is used to uniquely identify a VMO that will be passed to\n Request in an SdmmcBufferRegion. VMO IDs are chosen by the caller, and may be any uint32\n value.\n Registers a VMO and transfers ownership to the protocol implementation. vmo_rights is a bit\n field containing SdmmcVmoRight values, and determines the read/write permissions used by\n the implementation when pinning or mapping the VMO. The implementation may pin vmo during\n this call or any time it is used in a request, and may keep it pinned until the VMO is\n unregistered. client_id may be in [0, SDMMC_MAX_CLIENT_ID] and identifies the ID space for\n this VMO to be registered in (that is, two different VMOs may use the same ID if they are\n registered for different clients).\n"]
5130 fn register_vmo(
5131 &mut self,
5132
5133 request: ::fidl_next::Request<sdmmc::RegisterVmo, ___T>,
5134
5135 responder: ::fidl_next::Responder<sdmmc::RegisterVmo, ___T>,
5136 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5137
5138 #[doc = " The callee unmaps/unpins the VMO and returns ownership to the caller.\n"]
5139 fn unregister_vmo(
5140 &mut self,
5141
5142 request: ::fidl_next::Request<sdmmc::UnregisterVmo, ___T>,
5143
5144 responder: ::fidl_next::Responder<sdmmc::UnregisterVmo, ___T>,
5145 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5146
5147 #[doc = " Perform the requests in order, atomically (i.e., no intervening requests). Furthermore,\n calls are replied to in the order they are received. If an error occurs, abort any remaining\n requests. Else, return the response of the last request.\n\n The protocol implementation chooses whether or not to use DMA\n depending on the properties of the request and the capabilities of the controller.\n\n Clients are responsible for performing the following cache operations:\n\n After read requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE on buffers that\n have been mapped by the client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN_INVALIDATE on all other buffers.\n\n Note that writing to any portion of a buffer before Request has returned can corrupt the\n received data.\n\n Before write requests:\n - Call zx_cache_flush with ZX_CACHE_FLUSH_DATA on buffers that have been mapped by the\n client.\n - Call zx_vmo_op_range with ZX_VMO_OP_CACHE_CLEAN on all other buffers.\n"]
5148 fn request(
5149 &mut self,
5150
5151 request: ::fidl_next::Request<sdmmc::Request, ___T>,
5152
5153 responder: ::fidl_next::Responder<sdmmc::Request, ___T>,
5154 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5155}
5156
5157impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Sdmmc
5158where
5159 ___H: SdmmcServerHandler<___T> + ::core::marker::Send,
5160 ___T: ::fidl_next::Transport,
5161 for<'de> crate::wire::CqhciInitializeCommandQueueingRequest: ::fidl_next::Decode<
5162 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5163 Constraint = (),
5164 >,
5165 for<'de> crate::wire::SdmmcSetSignalVoltageRequest: ::fidl_next::Decode<
5166 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5167 Constraint = (),
5168 >,
5169 for<'de> crate::wire::SdmmcSetBusWidthRequest: ::fidl_next::Decode<
5170 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5171 Constraint = (),
5172 >,
5173 for<'de> crate::wire::SdmmcSetBusFreqRequest: ::fidl_next::Decode<
5174 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5175 Constraint = (),
5176 >,
5177 for<'de> crate::wire::SdmmcSetTimingRequest: ::fidl_next::Decode<
5178 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5179 Constraint = (),
5180 >,
5181 for<'de> crate::wire::SdmmcPerformTuningRequest: ::fidl_next::Decode<
5182 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5183 Constraint = (),
5184 >,
5185 for<'de> crate::wire::SdmmcRegisterInBandInterruptRequest: ::fidl_next::Decode<
5186 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5187 Constraint = (),
5188 >,
5189 for<'de> crate::wire::SdmmcRegisterVmoRequest: ::fidl_next::Decode<
5190 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5191 Constraint = (),
5192 >,
5193 for<'de> crate::wire::SdmmcUnregisterVmoRequest: ::fidl_next::Decode<
5194 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5195 Constraint = (),
5196 >,
5197 for<'de> crate::wire::SdmmcRequestRequest<'de>: ::fidl_next::Decode<
5198 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5199 Constraint = (),
5200 >,
5201{
5202 async fn on_one_way(
5203 handler: &mut ___H,
5204 mut message: ::fidl_next::Message<___T>,
5205 ) -> ::core::result::Result<
5206 (),
5207 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5208 > {
5209 match *message.header().ordinal {
5210 6808342210488695055 => {
5211 handler.ack_in_band_interrupt().await;
5212 Ok(())
5213 }
5214
5215 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5216 }
5217 }
5218
5219 async fn on_two_way(
5220 handler: &mut ___H,
5221 mut message: ::fidl_next::Message<___T>,
5222 responder: ::fidl_next::protocol::Responder<___T>,
5223 ) -> ::core::result::Result<
5224 (),
5225 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5226 > {
5227 match *message.header().ordinal {
5228 359559202570093266 => {
5229 let responder = ::fidl_next::Responder::from_untyped(responder);
5230
5231 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5232 Ok(decoded) => {
5233 handler
5234 .initialize_command_queueing(
5235 ::fidl_next::Request::from_decoded(decoded),
5236 responder,
5237 )
5238 .await;
5239 Ok(())
5240 }
5241 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5242 ordinal: 359559202570093266,
5243 error,
5244 }),
5245 }
5246 }
5247
5248 7267012061448928954 => {
5249 let responder = ::fidl_next::Responder::from_untyped(responder);
5250
5251 handler.enable_cqhci(responder).await;
5252 Ok(())
5253 }
5254
5255 4177196635683073751 => {
5256 let responder = ::fidl_next::Responder::from_untyped(responder);
5257
5258 handler.disable_cqhci(responder).await;
5259 Ok(())
5260 }
5261
5262 8475471856809867100 => {
5263 let responder = ::fidl_next::Responder::from_untyped(responder);
5264
5265 handler.host_info(responder).await;
5266 Ok(())
5267 }
5268
5269 5360485811549546918 => {
5270 let responder = ::fidl_next::Responder::from_untyped(responder);
5271
5272 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5273 Ok(decoded) => {
5274 handler
5275 .set_signal_voltage(
5276 ::fidl_next::Request::from_decoded(decoded),
5277 responder,
5278 )
5279 .await;
5280 Ok(())
5281 }
5282 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5283 ordinal: 5360485811549546918,
5284 error,
5285 }),
5286 }
5287 }
5288
5289 3438431046250338573 => {
5290 let responder = ::fidl_next::Responder::from_untyped(responder);
5291
5292 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5293 Ok(decoded) => {
5294 handler
5295 .set_bus_width(::fidl_next::Request::from_decoded(decoded), responder)
5296 .await;
5297 Ok(())
5298 }
5299 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5300 ordinal: 3438431046250338573,
5301 error,
5302 }),
5303 }
5304 }
5305
5306 6624771772063616636 => {
5307 let responder = ::fidl_next::Responder::from_untyped(responder);
5308
5309 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5310 Ok(decoded) => {
5311 handler
5312 .set_bus_freq(::fidl_next::Request::from_decoded(decoded), responder)
5313 .await;
5314 Ok(())
5315 }
5316 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5317 ordinal: 6624771772063616636,
5318 error,
5319 }),
5320 }
5321 }
5322
5323 7991421876873192632 => {
5324 let responder = ::fidl_next::Responder::from_untyped(responder);
5325
5326 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5327 Ok(decoded) => {
5328 handler
5329 .set_timing(::fidl_next::Request::from_decoded(decoded), responder)
5330 .await;
5331 Ok(())
5332 }
5333 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5334 ordinal: 7991421876873192632,
5335 error,
5336 }),
5337 }
5338 }
5339
5340 3335326454881665312 => {
5341 let responder = ::fidl_next::Responder::from_untyped(responder);
5342
5343 handler.hw_reset(responder).await;
5344 Ok(())
5345 }
5346
5347 5267400993243262226 => {
5348 let responder = ::fidl_next::Responder::from_untyped(responder);
5349
5350 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5351 Ok(decoded) => {
5352 handler
5353 .perform_tuning(::fidl_next::Request::from_decoded(decoded), responder)
5354 .await;
5355 Ok(())
5356 }
5357 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5358 ordinal: 5267400993243262226,
5359 error,
5360 }),
5361 }
5362 }
5363
5364 7280830926204192948 => {
5365 let responder = ::fidl_next::Responder::from_untyped(responder);
5366
5367 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5368 Ok(decoded) => {
5369 handler
5370 .register_in_band_interrupt(
5371 ::fidl_next::Request::from_decoded(decoded),
5372 responder,
5373 )
5374 .await;
5375 Ok(())
5376 }
5377 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5378 ordinal: 7280830926204192948,
5379 error,
5380 }),
5381 }
5382 }
5383
5384 1214620982318353152 => {
5385 let responder = ::fidl_next::Responder::from_untyped(responder);
5386
5387 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5388 Ok(decoded) => {
5389 handler
5390 .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
5391 .await;
5392 Ok(())
5393 }
5394 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5395 ordinal: 1214620982318353152,
5396 error,
5397 }),
5398 }
5399 }
5400
5401 8712572721256898471 => {
5402 let responder = ::fidl_next::Responder::from_untyped(responder);
5403
5404 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5405 Ok(decoded) => {
5406 handler
5407 .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
5408 .await;
5409 Ok(())
5410 }
5411 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5412 ordinal: 8712572721256898471,
5413 error,
5414 }),
5415 }
5416 }
5417
5418 2766657126441407958 => {
5419 let responder = ::fidl_next::Responder::from_untyped(responder);
5420
5421 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5422 Ok(decoded) => {
5423 handler
5424 .request(::fidl_next::Request::from_decoded(decoded), responder)
5425 .await;
5426 Ok(())
5427 }
5428 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5429 ordinal: 2766657126441407958,
5430 error,
5431 }),
5432 }
5433 }
5434
5435 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5436 }
5437 }
5438}
5439
5440impl<___T> SdmmcClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
5441
5442impl<___H, ___T> SdmmcLocalClientHandler<___T> for ::fidl_next::Local<___H>
5443where
5444 ___H: SdmmcClientHandler<___T>,
5445 ___T: ::fidl_next::Transport,
5446{
5447}
5448
5449impl<___H, ___T> SdmmcLocalServerHandler<___T> for ::fidl_next::Local<___H>
5450where
5451 ___H: SdmmcServerHandler<___T>,
5452 ___T: ::fidl_next::Transport,
5453{
5454 async fn initialize_command_queueing(
5455 &mut self,
5456
5457 request: ::fidl_next::Request<sdmmc::InitializeCommandQueueing, ___T>,
5458
5459 responder: ::fidl_next::Responder<sdmmc::InitializeCommandQueueing, ___T>,
5460 ) {
5461 ___H::initialize_command_queueing(&mut self.0, request, responder).await
5462 }
5463
5464 async fn enable_cqhci(&mut self, responder: ::fidl_next::Responder<sdmmc::EnableCqhci, ___T>) {
5465 ___H::enable_cqhci(&mut self.0, responder).await
5466 }
5467
5468 async fn disable_cqhci(
5469 &mut self,
5470
5471 responder: ::fidl_next::Responder<sdmmc::DisableCqhci, ___T>,
5472 ) {
5473 ___H::disable_cqhci(&mut self.0, responder).await
5474 }
5475
5476 async fn host_info(&mut self, responder: ::fidl_next::Responder<sdmmc::HostInfo, ___T>) {
5477 ___H::host_info(&mut self.0, responder).await
5478 }
5479
5480 async fn set_signal_voltage(
5481 &mut self,
5482
5483 request: ::fidl_next::Request<sdmmc::SetSignalVoltage, ___T>,
5484
5485 responder: ::fidl_next::Responder<sdmmc::SetSignalVoltage, ___T>,
5486 ) {
5487 ___H::set_signal_voltage(&mut self.0, request, responder).await
5488 }
5489
5490 async fn set_bus_width(
5491 &mut self,
5492
5493 request: ::fidl_next::Request<sdmmc::SetBusWidth, ___T>,
5494
5495 responder: ::fidl_next::Responder<sdmmc::SetBusWidth, ___T>,
5496 ) {
5497 ___H::set_bus_width(&mut self.0, request, responder).await
5498 }
5499
5500 async fn set_bus_freq(
5501 &mut self,
5502
5503 request: ::fidl_next::Request<sdmmc::SetBusFreq, ___T>,
5504
5505 responder: ::fidl_next::Responder<sdmmc::SetBusFreq, ___T>,
5506 ) {
5507 ___H::set_bus_freq(&mut self.0, request, responder).await
5508 }
5509
5510 async fn set_timing(
5511 &mut self,
5512
5513 request: ::fidl_next::Request<sdmmc::SetTiming, ___T>,
5514
5515 responder: ::fidl_next::Responder<sdmmc::SetTiming, ___T>,
5516 ) {
5517 ___H::set_timing(&mut self.0, request, responder).await
5518 }
5519
5520 async fn hw_reset(&mut self, responder: ::fidl_next::Responder<sdmmc::HwReset, ___T>) {
5521 ___H::hw_reset(&mut self.0, responder).await
5522 }
5523
5524 async fn perform_tuning(
5525 &mut self,
5526
5527 request: ::fidl_next::Request<sdmmc::PerformTuning, ___T>,
5528
5529 responder: ::fidl_next::Responder<sdmmc::PerformTuning, ___T>,
5530 ) {
5531 ___H::perform_tuning(&mut self.0, request, responder).await
5532 }
5533
5534 async fn register_in_band_interrupt(
5535 &mut self,
5536
5537 request: ::fidl_next::Request<sdmmc::RegisterInBandInterrupt, ___T>,
5538
5539 responder: ::fidl_next::Responder<sdmmc::RegisterInBandInterrupt, ___T>,
5540 ) {
5541 ___H::register_in_band_interrupt(&mut self.0, request, responder).await
5542 }
5543
5544 async fn ack_in_band_interrupt(&mut self) {
5545 ___H::ack_in_band_interrupt(&mut self.0).await
5546 }
5547
5548 async fn register_vmo(
5549 &mut self,
5550
5551 request: ::fidl_next::Request<sdmmc::RegisterVmo, ___T>,
5552
5553 responder: ::fidl_next::Responder<sdmmc::RegisterVmo, ___T>,
5554 ) {
5555 ___H::register_vmo(&mut self.0, request, responder).await
5556 }
5557
5558 async fn unregister_vmo(
5559 &mut self,
5560
5561 request: ::fidl_next::Request<sdmmc::UnregisterVmo, ___T>,
5562
5563 responder: ::fidl_next::Responder<sdmmc::UnregisterVmo, ___T>,
5564 ) {
5565 ___H::unregister_vmo(&mut self.0, request, responder).await
5566 }
5567
5568 async fn request(
5569 &mut self,
5570
5571 request: ::fidl_next::Request<sdmmc::Request, ___T>,
5572
5573 responder: ::fidl_next::Responder<sdmmc::Request, ___T>,
5574 ) {
5575 ___H::request(&mut self.0, request, responder).await
5576 }
5577}
5578
5579#[derive(Debug)]
5581pub struct SdmmcService;
5582
5583impl ::fidl_next::DiscoverableService for SdmmcService {
5584 const SERVICE_NAME: &'static str = "fuchsia.hardware.sdmmc.SdmmcService";
5585 const MEMBER_NAMES: &'static [&'static str] = &["sdmmc", "inline_crypto"];
5586}
5587
5588impl ::fidl_next::HasServiceRequest<::fdf_fidl::DriverChannel> for SdmmcService {}
5589
5590impl<___C> ::fidl_next::Service<___C> for SdmmcService
5591where
5592 ___C: ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>,
5593 ___C: ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>,
5594{
5595 type Connector = SdmmcServiceConnector<___C>;
5596}
5597
5598#[repr(transparent)]
5600pub struct SdmmcServiceConnector<___C> {
5601 #[allow(dead_code)]
5602 connector: ___C,
5603}
5604
5605impl<___C> SdmmcServiceConnector<___C>
5606where
5607 ___C: ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>,
5608 ___C: ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>,
5609{
5610 pub fn sdmmc(
5612 &self,
5613 server_end: ::fidl_next::ServerEnd<crate::Sdmmc, ::fdf_fidl::DriverChannel>,
5614 ) -> ::core::result::Result<
5615 (),
5616 <___C as ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>>::Error,
5617 > {
5618 ::fidl_next::protocol::ServiceConnector::<::fdf_fidl::DriverChannel>::connect_to_member(
5619 &self.connector,
5620 "sdmmc",
5621 server_end.into_untyped(),
5622 )
5623 }
5624
5625 pub fn inline_crypto(
5627 &self,
5628 server_end: ::fidl_next::ServerEnd<
5629 ::fidl_next_fuchsia_hardware_inlineencryption::DriverDevice,
5630 ::fdf_fidl::DriverChannel,
5631 >,
5632 ) -> ::core::result::Result<
5633 (),
5634 <___C as ::fidl_next::protocol::ServiceConnector<::fdf_fidl::DriverChannel>>::Error,
5635 > {
5636 ::fidl_next::protocol::ServiceConnector::<::fdf_fidl::DriverChannel>::connect_to_member(
5637 &self.connector,
5638 "inline_crypto",
5639 server_end.into_untyped(),
5640 )
5641 }
5642}
5643
5644pub trait SdmmcServiceHandler {
5646 fn sdmmc(&self, server_end: ::fidl_next::ServerEnd<crate::Sdmmc, ::fdf_fidl::DriverChannel>);
5648
5649 fn inline_crypto(
5651 &self,
5652 server_end: ::fidl_next::ServerEnd<
5653 ::fidl_next_fuchsia_hardware_inlineencryption::DriverDevice,
5654 ::fdf_fidl::DriverChannel,
5655 >,
5656 );
5657}
5658
5659impl<___H, ___T> ::fidl_next::DispatchServiceHandler<___H, ___T> for SdmmcService
5660where
5661 ___H: SdmmcServiceHandler,
5662 ::fdf_fidl::DriverChannel: ::fidl_next::InstanceFromServiceTransport<___T>,
5663 ::fdf_fidl::DriverChannel: ::fidl_next::InstanceFromServiceTransport<___T>,
5664{
5665 fn on_connection(handler: &___H, member: &str, server_end: ___T) {
5666 use ::fidl_next::InstanceFromServiceTransport;
5667 match member {
5668 "sdmmc" => handler.sdmmc(::fidl_next::ServerEnd::from_untyped(
5669 ::fdf_fidl::DriverChannel::from_service_transport(server_end),
5670 )),
5671
5672 "inline_crypto" => handler.inline_crypto(::fidl_next::ServerEnd::from_untyped(
5673 ::fdf_fidl::DriverChannel::from_service_transport(server_end),
5674 )),
5675
5676 _ => unreachable!(),
5677 }
5678 }
5679}
5680
5681pub use fidl_next_common_fuchsia_hardware_sdmmc::*;