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), handles) = message.take_arena_boxes() else {
243            return Err(fidl::Error::Invalid);
244        };
245        let mut handles =
246            handles
247                .map(|handles| {
248                    arena.try_insert_from_iter(handles.into_iter().map(|handle| unsafe {
249                        fidl_driver::encoding::mixed_into_handle_info(handle)
250                    }))
251                })
252                .transpose();
253        let res = match handles {
254            Ok(ref mut handles) => {
255                Self::read_from(&*body, handles.as_deref_mut().unwrap_or(&mut []))?
256            }
257            Err(_) => return Err(fidl::Error::Invalid),
258        };
259        std::mem::drop((body, handles));
260        Ok((message.take_arena(), res))
261    }
262
263    /// Name of the method defined in FIDL
264    pub fn method_name(&self) -> &'static str {
265        match *self {
266            DeviceRequest::GetMaxTransferSize { .. } => "get_max_transfer_size",
267            DeviceRequest::SetBitrate { .. } => "set_bitrate",
268            DeviceRequest::Transact { .. } => "transact",
269            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
270                "unknown one-way method"
271            }
272            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
273                "unknown two-way method"
274            }
275        }
276    }
277}
278
279/// Like [`DeviceRequest::read_from_message`] except it drops the [`Arena`].
280#[cfg(feature = "driver")]
281impl std::convert::TryFrom<fdf::Message<[u8]>> for DeviceRequest {
282    type Error = fidl::Error;
283    fn try_from(msg: fdf::Message<[u8]>) -> Result<DeviceRequest, fidl::Error> {
284        Ok(DeviceRequest::read_from_message(msg)?.1)
285    }
286}
287
288#[must_use = "FIDL methods require a response to be sent"]
289#[cfg(feature = "driver")]
290#[derive(Debug)]
291pub struct DeviceGetMaxTransferSizeResponder {
292    tx_id: u32,
293}
294
295#[cfg(feature = "driver")]
296impl DeviceGetMaxTransferSizeResponder {
297    pub fn send_response(
298        &self,
299        server_handle: &fdf::Channel<[u8]>,
300        mut result: Result<u64, i32>,
301    ) -> Result<(), fidl::Error> {
302        let msg = fidl::encoding::TransactionMessage {
303            header: fidl::encoding::TransactionHeader::new(
304                self.tx_id,
305                0x4717665a97d2d719,
306                fidl::encoding::DynamicFlags::FLEXIBLE,
307            ),
308            body: fidl::encoding::FlexibleResult::new(result.map(|size| (size,))),
309        };
310        fidl::encoding::with_tls_encoded::<
311            fidl::encoding::TransactionMessageType<
312                fidl::encoding::FlexibleResultType<DeviceGetMaxTransferSizeResponse, i32>,
313            >,
314            fidl::encoding::DefaultFuchsiaResourceDialect,
315            (),
316        >(msg, |body, _handles| {
317            server_handle
318                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
319                .unwrap();
320            Ok(())
321        })
322    }
323}
324
325#[must_use = "FIDL methods require a response to be sent"]
326#[cfg(feature = "driver")]
327#[derive(Debug)]
328pub struct DeviceSetBitrateResponder {
329    tx_id: u32,
330}
331
332#[cfg(feature = "driver")]
333impl DeviceSetBitrateResponder {
334    pub fn send_response(
335        &self,
336        server_handle: &fdf::Channel<[u8]>,
337        mut result: Result<(), i32>,
338    ) -> Result<(), fidl::Error> {
339        let msg = fidl::encoding::TransactionMessage {
340            header: fidl::encoding::TransactionHeader::new(
341                self.tx_id,
342                0x71b6e880efd7faf4,
343                fidl::encoding::DynamicFlags::FLEXIBLE,
344            ),
345            body: fidl::encoding::FlexibleResult::new(result),
346        };
347        fidl::encoding::with_tls_encoded::<
348            fidl::encoding::TransactionMessageType<
349                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
350            >,
351            fidl::encoding::DefaultFuchsiaResourceDialect,
352            (),
353        >(msg, |body, _handles| {
354            server_handle
355                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
356                .unwrap();
357            Ok(())
358        })
359    }
360}
361
362#[must_use = "FIDL methods require a response to be sent"]
363#[cfg(feature = "driver")]
364#[derive(Debug)]
365pub struct DeviceTransactResponder {
366    tx_id: u32,
367}
368
369#[cfg(feature = "driver")]
370impl DeviceTransactResponder {
371    pub fn send_response(
372        &self,
373        server_handle: &fdf::Channel<[u8]>,
374        mut result: Result<&[ReadData], i32>,
375    ) -> Result<(), fidl::Error> {
376        let msg = fidl::encoding::TransactionMessage {
377            header: fidl::encoding::TransactionHeader::new(
378                self.tx_id,
379                0x59ad11290fc1b9a6,
380                fidl::encoding::DynamicFlags::FLEXIBLE,
381            ),
382            body: fidl::encoding::FlexibleResult::new(result.map(|read| (read,))),
383        };
384        fidl::encoding::with_tls_encoded::<
385            fidl::encoding::TransactionMessageType<
386                fidl::encoding::FlexibleResultType<DeviceTransactResponse, i32>,
387            >,
388            fidl::encoding::DefaultFuchsiaResourceDialect,
389            (),
390        >(msg, |body, _handles| {
391            server_handle
392                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
393                .unwrap();
394            Ok(())
395        })
396    }
397}
398
399#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
400pub struct ServiceMarker;
401
402#[cfg(target_os = "fuchsia")]
403impl fidl::endpoints::ServiceMarker for ServiceMarker {
404    type Proxy = ServiceProxy;
405    type Request = ServiceRequest;
406    const SERVICE_NAME: &'static str = "fuchsia.hardware.i2cimpl.Service";
407}
408
409/// A request for one of the member protocols of Service.
410///
411#[cfg(target_os = "fuchsia")]
412pub enum ServiceRequest {}
413
414#[cfg(target_os = "fuchsia")]
415impl fidl::endpoints::ServiceRequest for ServiceRequest {
416    type Service = ServiceMarker;
417
418    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
419        match name {
420            _ => panic!("no such member protocol name for service Service"),
421        }
422    }
423
424    fn member_names() -> &'static [&'static str] {
425        &[]
426    }
427}
428#[cfg(target_os = "fuchsia")]
429pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
430
431#[cfg(target_os = "fuchsia")]
432impl fidl::endpoints::ServiceProxy for ServiceProxy {
433    type Service = ServiceMarker;
434
435    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
436        Self(opener)
437    }
438}
439
440#[cfg(target_os = "fuchsia")]
441impl ServiceProxy {
442    pub fn instance_name(&self) -> &str {
443        self.0.instance_name()
444    }
445}
446
447mod internal {
448    use super::*;
449}
fidl_fuchsia_hardware_i2cimpl/fidl_fuchsia_hardware_i2cimpl.rs

fidl_fuchsia_hardware_i2cimpl/
fidl_fuchsia_hardware_i2cimpl.rs
