Trait DeviceLocalServerHandler 

pub trait DeviceLocalServerHandler<___T: Transport = Channel> {
    // Required methods
    fn register_read(
        &mut self,
        request: Request<RegisterRead, ___T>,
        responder: Responder<RegisterRead, ___T>,
    ) -> impl Future<Output = ()>;
    fn register_write(
        &mut self,
        request: Request<RegisterWrite, ___T>,
        responder: Responder<RegisterWrite, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_properties(
        &mut self,
        responder: Responder<GetProperties, ___T>,
    ) -> impl Future<Output = ()>;
    fn watch_controller_write_commands(
        &mut self,
        request: Request<WatchControllerWriteCommands, ___T>,
        responder: Responder<WatchControllerWriteCommands, ___T>,
    ) -> impl Future<Output = ()>;
    fn cancel_watch_controller_write_commands(
        &mut self,
        request: Request<CancelWatchControllerWriteCommands, ___T>,
        responder: Responder<CancelWatchControllerWriteCommands, ___T>,
    ) -> impl Future<Output = ()>;

    // Provided method
    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl Future<Output = ()> { ... }
}

A server handler for the Device protocol.

See Device for more details.

Required Methods

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

Issue register read commands to the SPMI device. The implementation may choose which SPMI variation (e.g. extended, long) to use. When successful, it returns size_bytes in data read contiguously starting from address in the device.

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

Issue register write commands to the SPMI device. The implementation may choose which SPMI variation (e.g. extended, long) to use. When this command is successful, data will be written contiguously starting from address in the device.

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

Get the properties of the SPMI device.

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

Hanging-get method to receive controller write commands from the device. address and size specify the register range to monitor for commands. Multiple overlapping calls to this method are not allowed. Returns INVALID_ARGS if address or size are invalid, or BAD_STATE if another call is pending for this register range. Returns CANCELED if CancelWatchControllerWriteCommands() was called for this register range.

If this method is meant to keep the system awake (prevents suspension) while watch is setup, use the passed-in setup_wake_lease LeaseToken. Then, when the watch is triggered this method will return a second wake_lease LeaseToken to prevent suspension.

These keep alive wake lease tokens are provided by the Power Framework’s System Activity Governor. A driver supporting keep alive must be able to get wake_lease from System Activity Governor.

When wake_lease is closed, then the created wake lease keeping the system from suspending at the time of watch triggering is dropped. Hence, to guarantee that the system is not suspended by the Power Framework a client must either keep this wake_lease for as long as the system needs to stay awake, or a client must get its own wake lease from the Power Framework before it drops wake_lease to prevent suspension.

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

Cancels an pending call to WatchControllerWriteCommands. address and size must exactly match a previous call to WatchControllerWriteCommands(), otherwise NOT_FOUND is returned.

Provided Methods

fn on_unknown_interaction(&mut self, ordinal: u64) -> 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> DeviceLocalServerHandler<___T> for Local<___H>

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

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

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

async fn get_properties(&mut self, responder: Responder<GetProperties, ___T>)

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

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

async fn on_unknown_interaction(&mut self, ordinal: u64)

Implementors