fidl_fuchsia_hardware_i2cimpl/
fidl_fuchsia_hardware_i2cimpl.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_hardware_i2cimpl__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[cfg(feature = "driver")]
15#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
16pub struct DeviceMarker;
17
18#[cfg(feature = "driver")]
19impl fidl_driver::endpoints::DriverProtocolMarker for DeviceMarker {
20    const DEBUG_NAME: &'static str = "fuchsia.hardware.i2cimpl.Device";
21}
22pub type DeviceGetMaxTransferSizeResult = Result<u64, i32>;
23pub type DeviceSetBitrateResult = Result<(), i32>;
24pub type DeviceTransactResult = Result<Vec<ReadData>, i32>;
25
26/// Low-level protocol for i2c drivers.
27
28#[cfg(feature = "driver")]
29#[derive(Debug)]
30pub enum DeviceRequest {
31    GetMaxTransferSize {
32        responder: DeviceGetMaxTransferSizeResponder,
33    },
34    /// Sets the bitrate for the i2c bus in KHz units.
35    SetBitrate {
36        bitrate: u32,
37        responder: DeviceSetBitrateResponder,
38    },
39    /// |Transact| assumes that write ops write_data length are not zero.
40    /// |Transact| assumes that at least the last op has stop set to true.
41    ///
42    /// For each read-transaction, there will be a corresponding ReadData
43    /// returned. Write-transactions produce no data result.
44    Transact {
45        op: Vec<I2cImplOp>,
46        responder: DeviceTransactResponder,
47    },
48    /// An interaction was received which does not match any known method.
49    #[non_exhaustive]
50    _UnknownMethod {
51        /// Ordinal of the method that was called.
52        ordinal: u64,
53        method_type: fidl::MethodType,
54    },
55}
56
57#[cfg(feature = "driver")]
58impl DeviceRequest {
59    #[allow(irrefutable_let_patterns)]
60    pub fn into_get_max_transfer_size(self) -> Option<(DeviceGetMaxTransferSizeResponder)> {
61        if let DeviceRequest::GetMaxTransferSize { responder } = self {
62            Some((responder))
63        } else {
64            None
65        }
66    }
67
68    #[allow(irrefutable_let_patterns)]
69    pub fn into_set_bitrate(self) -> Option<(u32, DeviceSetBitrateResponder)> {
70        if let DeviceRequest::SetBitrate { bitrate, responder } = self {
71            Some((bitrate, responder))
72        } else {
73            None
74        }
75    }
76
77    #[allow(irrefutable_let_patterns)]
78    pub fn into_transact(self) -> Option<(Vec<I2cImplOp>, DeviceTransactResponder)> {
79        if let DeviceRequest::Transact { op, responder } = self {
80            Some((op, responder))
81        } else {
82            None
83        }
84    }
85
86    pub fn new_get_max_transfer_size(self, tx_id: u32) -> Self {
87        Self::GetMaxTransferSize { responder: DeviceGetMaxTransferSizeResponder { tx_id } }
88    }
89
90    pub fn new_set_bitrate(self, bitrate: u32, tx_id: u32) -> Self {
91        Self::SetBitrate { bitrate, responder: DeviceSetBitrateResponder { tx_id } }
92    }
93
94    pub fn new_transact(self, op: Vec<I2cImplOp>, tx_id: u32) -> Self {
95        Self::Transact { op, responder: DeviceTransactResponder { tx_id } }
96    }
97
98    pub fn r#get_max_transfer_size_as_message(
99        arena: fdf::Arena,
100        tx_id: u32,
101    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
102        let ordinal = 0x4717665a97d2d719;
103        let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
104        let body = ();
105        let msg = fidl::encoding::TransactionMessage {
106            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
107            body,
108        };
109        fidl::encoding::with_tls_encoded::<
110            fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
111            fidl::encoding::DefaultFuchsiaResourceDialect,
112            fdf::Message<[u8]>,
113        >(msg, |bytes, mut handles| {
114            let handles = arena.insert_from_iter(
115                std::mem::take(handles)
116                    .into_iter()
117                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
118            );
119            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
120        })
121    }
122
123    pub fn r#set_bitrate_as_message(
124        arena: fdf::Arena,
125        mut bitrate: u32,
126        tx_id: u32,
127    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
128        let ordinal = 0x71b6e880efd7faf4;
129        let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
130        let body = (bitrate,);
131        let msg = fidl::encoding::TransactionMessage {
132            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
133            body,
134        };
135        fidl::encoding::with_tls_encoded::<
136            fidl::encoding::TransactionMessageType<DeviceSetBitrateRequest>,
137            fidl::encoding::DefaultFuchsiaResourceDialect,
138            fdf::Message<[u8]>,
139        >(msg, |bytes, mut handles| {
140            let handles = arena.insert_from_iter(
141                std::mem::take(handles)
142                    .into_iter()
143                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
144            );
145            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
146        })
147    }
148
149    pub fn r#transact_as_message(
150        arena: fdf::Arena,
151        mut op: &[I2cImplOp],
152        tx_id: u32,
153    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
154        let ordinal = 0x59ad11290fc1b9a6;
155        let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
156        let body = (op,);
157        let msg = fidl::encoding::TransactionMessage {
158            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
159            body,
160        };
161        fidl::encoding::with_tls_encoded::<
162            fidl::encoding::TransactionMessageType<DeviceTransactRequest>,
163            fidl::encoding::DefaultFuchsiaResourceDialect,
164            fdf::Message<[u8]>,
165        >(msg, |bytes, mut handles| {
166            let handles = arena.insert_from_iter(
167                std::mem::take(handles)
168                    .into_iter()
169                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
170            );
171            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
172        })
173    }
174
175    #[allow(irrefutable_let_patterns)]
176    pub fn read_from(bytes: &[u8], _handles: &mut [zx::HandleInfo]) -> Result<Self, fidl::Error> {
177        let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
178
179        match header.ordinal {
180            0x4717665a97d2d719 => {
181                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
182                let mut req = fidl::new_empty!(
183                    fidl::encoding::EmptyPayload,
184                    fidl::encoding::DefaultFuchsiaResourceDialect
185                );
186                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
187                Ok(DeviceRequest::GetMaxTransferSize {
188                    responder: DeviceGetMaxTransferSizeResponder { tx_id: header.tx_id },
189                })
190            }
191            0x71b6e880efd7faf4 => {
192                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
193                let mut req = fidl::new_empty!(
194                    DeviceSetBitrateRequest,
195                    fidl::encoding::DefaultFuchsiaResourceDialect
196                );
197                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetBitrateRequest>(&header, _body_bytes, _handles, &mut req)?;
198                Ok(DeviceRequest::SetBitrate {
199                    bitrate: req.bitrate,
200
201                    responder: DeviceSetBitrateResponder { tx_id: header.tx_id },
202                })
203            }
204            0x59ad11290fc1b9a6 => {
205                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
206                let mut req = fidl::new_empty!(
207                    DeviceTransactRequest,
208                    fidl::encoding::DefaultFuchsiaResourceDialect
209                );
210                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceTransactRequest>(&header, _body_bytes, _handles, &mut req)?;
211                Ok(DeviceRequest::Transact {
212                    op: req.op,
213
214                    responder: DeviceTransactResponder { tx_id: header.tx_id },
215                })
216            }
217            _ if header.tx_id == 0
218                && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
219            {
220                Ok(DeviceRequest::_UnknownMethod {
221                    ordinal: header.ordinal,
222                    method_type: fidl::MethodType::OneWay,
223                })
224            }
225            _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
226                Ok(DeviceRequest::_UnknownMethod {
227                    ordinal: header.ordinal,
228                    method_type: fidl::MethodType::TwoWay,
229                })
230            }
231            _ => Err(fidl::Error::UnknownOrdinal {
232                ordinal: header.ordinal,
233                protocol_name:
234                    <DeviceMarker as fidl_driver::endpoints::DriverProtocolMarker>::DEBUG_NAME,
235            }),
236        }
237    }
238
239    pub fn read_from_message(
240        mut message: fdf::Message<[u8]>,
241    ) -> Result<(fdf::Arena, Self), fidl::Error> {
242        let (arena, Some(body), Some(handles)) = message.take_arena_boxes() else {
243            return Err(fidl::Error::Invalid);
244        };
245        let mut handles = arena.try_insert_from_iter(
246            handles
247                .into_iter()
248                .map(|handle| unsafe { fidl_driver::encoding::mixed_into_handle_info(handle) }),
249        );
250        let res = match handles {
251            Ok(ref mut handles) => Self::read_from(&*body, handles)?,
252            Err(_) => return Err(fidl::Error::Invalid),
253        };
254        std::mem::drop((body, handles));
255        Ok((message.take_arena(), res))
256    }
257
258    /// Name of the method defined in FIDL
259    pub fn method_name(&self) -> &'static str {
260        match *self {
261            DeviceRequest::GetMaxTransferSize { .. } => "get_max_transfer_size",
262            DeviceRequest::SetBitrate { .. } => "set_bitrate",
263            DeviceRequest::Transact { .. } => "transact",
264            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
265                "unknown one-way method"
266            }
267            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
268                "unknown two-way method"
269            }
270        }
271    }
272}
273
274/// Like [`DeviceRequest::read_from_message`] except it drops the [`Arena`].
275#[cfg(feature = "driver")]
276impl std::convert::TryFrom<fdf::Message<[u8]>> for DeviceRequest {
277    type Error = fidl::Error;
278    fn try_from(msg: fdf::Message<[u8]>) -> Result<DeviceRequest, fidl::Error> {
279        Ok(DeviceRequest::read_from_message(msg)?.1)
280    }
281}
282
283#[must_use = "FIDL methods require a response to be sent"]
284#[cfg(feature = "driver")]
285#[derive(Debug)]
286pub struct DeviceGetMaxTransferSizeResponder {
287    tx_id: u32,
288}
289
290#[cfg(feature = "driver")]
291impl DeviceGetMaxTransferSizeResponder {
292    pub fn send_response(
293        &self,
294        server_handle: &fdf::Channel<[u8]>,
295        mut result: Result<u64, i32>,
296    ) -> Result<(), fidl::Error> {
297        let msg = fidl::encoding::TransactionMessage {
298            header: fidl::encoding::TransactionHeader::new(
299                self.tx_id,
300                0x4717665a97d2d719,
301                fidl::encoding::DynamicFlags::FLEXIBLE,
302            ),
303            body: fidl::encoding::FlexibleResult::new(result.map(|size| (size,))),
304        };
305        fidl::encoding::with_tls_encoded::<
306            fidl::encoding::TransactionMessageType<
307                fidl::encoding::FlexibleResultType<DeviceGetMaxTransferSizeResponse, i32>,
308            >,
309            fidl::encoding::DefaultFuchsiaResourceDialect,
310            (),
311        >(msg, |body, _handles| {
312            server_handle
313                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
314                .unwrap();
315            Ok(())
316        })
317    }
318}
319
320#[must_use = "FIDL methods require a response to be sent"]
321#[cfg(feature = "driver")]
322#[derive(Debug)]
323pub struct DeviceSetBitrateResponder {
324    tx_id: u32,
325}
326
327#[cfg(feature = "driver")]
328impl DeviceSetBitrateResponder {
329    pub fn send_response(
330        &self,
331        server_handle: &fdf::Channel<[u8]>,
332        mut result: Result<(), i32>,
333    ) -> Result<(), fidl::Error> {
334        let msg = fidl::encoding::TransactionMessage {
335            header: fidl::encoding::TransactionHeader::new(
336                self.tx_id,
337                0x71b6e880efd7faf4,
338                fidl::encoding::DynamicFlags::FLEXIBLE,
339            ),
340            body: fidl::encoding::FlexibleResult::new(result),
341        };
342        fidl::encoding::with_tls_encoded::<
343            fidl::encoding::TransactionMessageType<
344                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
345            >,
346            fidl::encoding::DefaultFuchsiaResourceDialect,
347            (),
348        >(msg, |body, _handles| {
349            server_handle
350                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
351                .unwrap();
352            Ok(())
353        })
354    }
355}
356
357#[must_use = "FIDL methods require a response to be sent"]
358#[cfg(feature = "driver")]
359#[derive(Debug)]
360pub struct DeviceTransactResponder {
361    tx_id: u32,
362}
363
364#[cfg(feature = "driver")]
365impl DeviceTransactResponder {
366    pub fn send_response(
367        &self,
368        server_handle: &fdf::Channel<[u8]>,
369        mut result: Result<&[ReadData], i32>,
370    ) -> Result<(), fidl::Error> {
371        let msg = fidl::encoding::TransactionMessage {
372            header: fidl::encoding::TransactionHeader::new(
373                self.tx_id,
374                0x59ad11290fc1b9a6,
375                fidl::encoding::DynamicFlags::FLEXIBLE,
376            ),
377            body: fidl::encoding::FlexibleResult::new(result.map(|read| (read,))),
378        };
379        fidl::encoding::with_tls_encoded::<
380            fidl::encoding::TransactionMessageType<
381                fidl::encoding::FlexibleResultType<DeviceTransactResponse, i32>,
382            >,
383            fidl::encoding::DefaultFuchsiaResourceDialect,
384            (),
385        >(msg, |body, _handles| {
386            server_handle
387                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
388                .unwrap();
389            Ok(())
390        })
391    }
392}
393
394#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
395pub struct ServiceMarker;
396
397#[cfg(target_os = "fuchsia")]
398impl fidl::endpoints::ServiceMarker for ServiceMarker {
399    type Proxy = ServiceProxy;
400    type Request = ServiceRequest;
401    const SERVICE_NAME: &'static str = "fuchsia.hardware.i2cimpl.Service";
402}
403
404/// A request for one of the member protocols of Service.
405///
406#[cfg(target_os = "fuchsia")]
407pub enum ServiceRequest {}
408
409#[cfg(target_os = "fuchsia")]
410impl fidl::endpoints::ServiceRequest for ServiceRequest {
411    type Service = ServiceMarker;
412
413    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
414        match name {
415            _ => panic!("no such member protocol name for service Service"),
416        }
417    }
418
419    fn member_names() -> &'static [&'static str] {
420        &[]
421    }
422}
423#[cfg(target_os = "fuchsia")]
424pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
425
426#[cfg(target_os = "fuchsia")]
427impl fidl::endpoints::ServiceProxy for ServiceProxy {
428    type Service = ServiceMarker;
429
430    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
431        Self(opener)
432    }
433}
434
435#[cfg(target_os = "fuchsia")]
436impl ServiceProxy {
437    pub fn instance_name(&self) -> &str {
438        self.0.instance_name()
439    }
440}
441
442mod internal {
443    use super::*;
444}
fidl_fuchsia_hardware_i2cimpl/fidl_fuchsia_hardware_i2cimpl.rs

fidl_fuchsia_hardware_i2cimpl/
fidl_fuchsia_hardware_i2cimpl.rs
