Trait SpiImplLocalServerHandler 

pub trait SpiImplLocalServerHandler<___T: Transport = DriverChannel> {
    // Required methods
    fn get_chip_select_count(
        &mut self,
        responder: Responder<GetChipSelectCount, ___T>,
    ) -> impl Future<Output = ()>;
    fn transmit_vector(
        &mut self,
        request: Request<TransmitVector, ___T>,
        responder: Responder<TransmitVector, ___T>,
    ) -> impl Future<Output = ()>;
    fn receive_vector(
        &mut self,
        request: Request<ReceiveVector, ___T>,
        responder: Responder<ReceiveVector, ___T>,
    ) -> impl Future<Output = ()>;
    fn exchange_vector(
        &mut self,
        request: Request<ExchangeVector, ___T>,
        responder: Responder<ExchangeVector, ___T>,
    ) -> impl Future<Output = ()>;
    fn lock_bus(
        &mut self,
        request: Request<LockBus, ___T>,
        responder: Responder<LockBus, ___T>,
    ) -> impl Future<Output = ()>;
    fn unlock_bus(
        &mut self,
        request: Request<UnlockBus, ___T>,
        responder: Responder<UnlockBus, ___T>,
    ) -> impl Future<Output = ()>;
    fn register_vmo(
        &mut self,
        request: Request<RegisterVmo, ___T>,
        responder: Responder<RegisterVmo, ___T>,
    ) -> impl Future<Output = ()>;
    fn unregister_vmo(
        &mut self,
        request: Request<UnregisterVmo, ___T>,
        responder: Responder<UnregisterVmo, ___T>,
    ) -> impl Future<Output = ()>;
    fn release_registered_vmos(
        &mut self,
        request: Request<ReleaseRegisteredVmos, ___T>,
    ) -> impl Future<Output = ()>;
    fn transmit_vmo(
        &mut self,
        request: Request<TransmitVmo, ___T>,
        responder: Responder<TransmitVmo, ___T>,
    ) -> impl Future<Output = ()>;
    fn receive_vmo(
        &mut self,
        request: Request<ReceiveVmo, ___T>,
        responder: Responder<ReceiveVmo, ___T>,
    ) -> impl Future<Output = ()>;
    fn exchange_vmo(
        &mut self,
        request: Request<ExchangeVmo, ___T>,
        responder: Responder<ExchangeVmo, ___T>,
    ) -> impl Future<Output = ()>;
}

A server handler for the SpiImpl protocol.

See SpiImpl for more details.

Required Methods

fn get_chip_select_count( &mut self, responder: Responder<GetChipSelectCount, ___T>, ) -> impl Future<Output = ()>

Returns the number of chip select lines available or provided by the driver instance. To be used as a limit on the acceptable values for the `chip_select’ field in the Exchange() and ExchangeVmo() methods.

fn transmit_vector( &mut self, request: Request<TransmitVector, ___T>, responder: Responder<TransmitVector, ___T>, ) -> impl Future<Output = ()>

Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.

fn receive_vector( &mut self, request: Request<ReceiveVector, ___T>, responder: Responder<ReceiveVector, ___T>, ) -> impl Future<Output = ()>

Half-duplex receive data from a SPI device; always reads the full size requested.

fn exchange_vector( &mut self, request: Request<ExchangeVector, ___T>, responder: Responder<ExchangeVector, ___T>, ) -> impl Future<Output = ()>

Full-duplex SPI transaction. Received data will exactly equal the length of the transmit buffer.

fn lock_bus( &mut self, request: Request<LockBus, ___T>, responder: Responder<LockBus, ___T>, ) -> impl Future<Output = ()>

Lock the bus.

fn unlock_bus( &mut self, request: Request<UnlockBus, ___T>, responder: Responder<UnlockBus, ___T>, ) -> impl Future<Output = ()>

Unlock the bus.

fn register_vmo( &mut self, request: Request<RegisterVmo, ___T>, responder: Responder<RegisterVmo, ___T>, ) -> impl Future<Output = ()>

rights is a bit field containing SpiVmoRight values, and determines the read/write permissions used by the implementation when pinning or mapping the VMO.

fn unregister_vmo( &mut self, request: Request<UnregisterVmo, ___T>, responder: Responder<UnregisterVmo, ___T>, ) -> impl Future<Output = ()>

fn release_registered_vmos( &mut self, request: Request<ReleaseRegisteredVmos, ___T>, ) -> impl Future<Output = ()>

Release all VMOs registered to this chip_select. Called by the core driver after the client has disconnected and the VMOs are no longer needed.

fn transmit_vmo( &mut self, request: Request<TransmitVmo, ___T>, responder: Responder<TransmitVmo, ___T>, ) -> impl Future<Output = ()>

fn receive_vmo( &mut self, request: Request<ReceiveVmo, ___T>, responder: Responder<ReceiveVmo, ___T>, ) -> impl Future<Output = ()>

fn exchange_vmo( &mut self, request: Request<ExchangeVmo, ___T>, responder: Responder<ExchangeVmo, ___T>, ) -> impl Future<Output = ()>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<___H, ___T> SpiImplLocalServerHandler<___T> for Local<___H>

where ___H: SpiImplServerHandler<___T>, ___T: Transport,

async fn get_chip_select_count( &mut self, responder: Responder<GetChipSelectCount, ___T>, )

async fn transmit_vector( &mut self, request: Request<TransmitVector, ___T>, responder: Responder<TransmitVector, ___T>, )

async fn receive_vector( &mut self, request: Request<ReceiveVector, ___T>, responder: Responder<ReceiveVector, ___T>, )

async fn exchange_vector( &mut self, request: Request<ExchangeVector, ___T>, responder: Responder<ExchangeVector, ___T>, )

async fn lock_bus( &mut self, request: Request<LockBus, ___T>, responder: Responder<LockBus, ___T>, )

async fn unlock_bus( &mut self, request: Request<UnlockBus, ___T>, responder: Responder<UnlockBus, ___T>, )

async fn register_vmo( &mut self, request: Request<RegisterVmo, ___T>, responder: Responder<RegisterVmo, ___T>, )

async fn unregister_vmo( &mut self, request: Request<UnregisterVmo, ___T>, responder: Responder<UnregisterVmo, ___T>, )

async fn release_registered_vmos( &mut self, request: Request<ReleaseRegisteredVmos, ___T>, )

async fn transmit_vmo( &mut self, request: Request<TransmitVmo, ___T>, responder: Responder<TransmitVmo, ___T>, )

async fn receive_vmo( &mut self, request: Request<ReceiveVmo, ___T>, responder: Responder<ReceiveVmo, ___T>, )

async fn exchange_vmo( &mut self, request: Request<ExchangeVmo, ___T>, responder: Responder<ExchangeVmo, ___T>, )

Implementors