Trait DeviceLocalServerHandler 

pub trait DeviceLocalServerHandler<___T: Transport = Channel> {
    // Required methods
    fn get_device_info(
        &mut self,
        responder: Responder<GetDeviceInfo, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_bar(
        &mut self,
        request: Request<GetBar, ___T>,
        responder: Responder<GetBar, ___T>,
    ) -> impl Future<Output = ()>;
    fn set_bus_mastering(
        &mut self,
        request: Request<SetBusMastering, ___T>,
        responder: Responder<SetBusMastering, ___T>,
    ) -> impl Future<Output = ()>;
    fn reset_device(
        &mut self,
        responder: Responder<ResetDevice, ___T>,
    ) -> impl Future<Output = ()>;
    fn ack_interrupt(
        &mut self,
        responder: Responder<AckInterrupt, ___T>,
    ) -> impl Future<Output = ()>;
    fn map_interrupt(
        &mut self,
        request: Request<MapInterrupt, ___T>,
        responder: Responder<MapInterrupt, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_interrupt_modes(
        &mut self,
        responder: Responder<GetInterruptModes, ___T>,
    ) -> impl Future<Output = ()>;
    fn set_interrupt_mode(
        &mut self,
        request: Request<SetInterruptMode, ___T>,
        responder: Responder<SetInterruptMode, ___T>,
    ) -> impl Future<Output = ()>;
    fn read_config8(
        &mut self,
        request: Request<ReadConfig8, ___T>,
        responder: Responder<ReadConfig8, ___T>,
    ) -> impl Future<Output = ()>;
    fn read_config16(
        &mut self,
        request: Request<ReadConfig16, ___T>,
        responder: Responder<ReadConfig16, ___T>,
    ) -> impl Future<Output = ()>;
    fn read_config32(
        &mut self,
        request: Request<ReadConfig32, ___T>,
        responder: Responder<ReadConfig32, ___T>,
    ) -> impl Future<Output = ()>;
    fn write_config8(
        &mut self,
        request: Request<WriteConfig8, ___T>,
        responder: Responder<WriteConfig8, ___T>,
    ) -> impl Future<Output = ()>;
    fn write_config16(
        &mut self,
        request: Request<WriteConfig16, ___T>,
        responder: Responder<WriteConfig16, ___T>,
    ) -> impl Future<Output = ()>;
    fn write_config32(
        &mut self,
        request: Request<WriteConfig32, ___T>,
        responder: Responder<WriteConfig32, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_capabilities(
        &mut self,
        request: Request<GetCapabilities, ___T>,
        responder: Responder<GetCapabilities, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_extended_capabilities(
        &mut self,
        request: Request<GetExtendedCapabilities, ___T>,
        responder: Responder<GetExtendedCapabilities, ___T>,
    ) -> impl Future<Output = ()>;
    fn get_bti(
        &mut self,
        request: Request<GetBti, ___T>,
        responder: Responder<GetBti, ___T>,
    ) -> impl Future<Output = ()>;
}

A server handler for the Device protocol.

See Device for more details.

Required Methods

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

Returns a structure containing device information from the configuration header.

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

Retrieves information for a specified Base Address Register (BAR). If the BAR contains MSI-X capability tables then an attempt will be made to return an MMIO region excluding those tables, if possible. Otherwise, an error will be returned.

Parameters: |bar_id|: The id of the BAR being requested. Valid range is [0, 6).

Errors: |ZX_ERR_ACCESS_DENIED|: The specified BAR does not have a driver-accessible region due to the presence of MSI-X tables. To use MSI-X see the |SetInterruptMode| method. |ZX_ERR_INTERNAL|: A bus driver error has occurred. |ZX_ERR_INVALID_ARGS|: The |bar_id| specified is outside of the acceptable range. |ZX_ERR_NOT_FOUND|: The specified |bar_id| does not exist for this device.

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

Enables or disables the bus mastering capability for the device.

Parameters: |enable|: true to enable bus mastering, false to disable.

Errors: |ZX_ERR_BAD_STATE|: Method was called while the device is disabled.

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

Initiates a function level reset for the device. This is a synchronous operation that will not return ontil the reset is complete. Interrupt operation of the device must be disabled before initiating a reset.

Errors: |ZX_ERR_BAD_STATE|: Interrupts were not disabled before calling |ResetDevice|. |ZX_ERR_NOT_SUPPORTED|: The device does not support reset. |ZX_ERR_TIMED_OUT|: The device did not complete its reset in the expected amount of time and is presumed to no longer be operating properly.

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

Alerts the bus driver to deassert the raised legacy interrupt so that it may be waited on again. Only used if |SetInterruptMode| was called with |PCI_INTERRUPT_MODE_LEGACY|.

Errors: |ZX_ERR_BAD_STATE|: device is not configured to use the Legacy interrupt mode.

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

Maps a device’s interrupt to a zx:interrupt. The device’s interrupt mode must already be configured with |SetInterruptMode|, and |which_irq| must be >= to the number of interrupts reported for that interrupt mode by |GetInterruptModes|. A Legacy interrupt may be mapped multiple times, but the handles will point to the same interrupt object. MSI & MSI-X interrupts may only have one outstanding mapping at a time per interrupt. Outstanding MSI & MSI-X interrupt handles must be closed before attempting to change the interrupt mode in a subsequent call to |SetInterruptMode|.

Parameters: |which_irq|: The id of the interrupt to map.

Errors: |ZX_ERR_ALREADY_BOUND|: The interrupt specified by |which_irq| is already mapped to a valid handle. |ZX_ERR_BAD_STATE|: interrupts are currently disabled for the device. |ZX_ERR_INVALID_ARGS|: |which_irq| is invalid for the mode.

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

Returns the supported interrupt modes for a device.

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

Configures the interrupt mode for a device. When changing from one interrupt mode to another the driver must ensure existing interrupt handles are closed beforehand.

Parameters: |mode|: The |InterruptMode| to request from the bus driver. |requested_irq_count|: The number of interrupts requested.

Errors: |ZX_ERR_BAD_STATE|: The driver attempted to change interrupt mode while existing handles to mapped MSIs exist. |ZX_ERR_INVALID_ARGS|: |requested_irq_count| is 0. |ZX_ERR_NOT_SUPPORTED|: The provided |mode| is not supported, or invalid.

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

Reads a byte from the device’s configuration space. |Offset| must be within [0x0, 0xFF] if PCI, or [0x0, 0xFFF) if PCIe. In most cases a device will be PCIe.

Parameters: |offset|: The offset into the device’s configuration space to read.

Errors: |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Reads two bytes from the device’s configuration space. |Offset| must be within [0x0, 0xFE] if PCI, or [0x0, 0xFFE] if PCIe. In most cases a device will be PCIe.

Parameters: |offset|: The offset into the device’s configuration space to read.

Errors: |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Reads four bytes from the device’s configuration space. |Offset| must be within [0x0, 0xFC] if PCI, or [0x0, 0xFFC] if PCIe. In most cases a device will be PCIe.

Parameters: |offset|: The offset into the device’s configuration space to read.

Errors: |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Writes a byte to the device’s configuration space. The acceptable ranges of |offset| for writes are [0x40, 0xFF] if PCI, or [0x40, 0xFFF] if PCIe. For most purposes a device will be PCIe.

Parameters |offset|: The offset into the device’s configuration space to read. |value|: The value to write.

Errors: |ZX_ERR_ACCESS_DENIED|: |offset| is within the device’s configuration header. |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Writes two bytes to the device’s configuration space. The acceptable ranges of |offset| for writes are [0x40, 0xFE] if PCI, or [0x40, 0xFFE] if PCIe. For most purposes a device will be PCIe.

Parameters |offset|: The offset into the device’s configuration space to read. |value|: The value to write.

Errors: |ZX_ERR_ACCESS_DENIED|: |offset| is within the device’s configuration header. |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Writes four bytes to the device’s configuration space. The acceptable ranges of |offset| for writes are [0x40, 0xFC] if PCI, or [0x40, 0xFFC] if PCIe. For most purposes a device will be PCIe.

Parameters |offset|: The offset into the device’s configuration space to read. |value|: The value to write.

Errors: |ZX_ERR_ACCESS_DENIED|: |offset| is within the device’s configuration header. |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.

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

Returns a vector of offsets in configuration space corresponding to capabilities matching the provided capability |id|. If no corresponding match is found then the vector will be empty.

Parameters: |id|: the capability id to search for.

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

Returns a vector of offsets in configuration space corresponding to extended capabilities matching the provided extended capability |id|. If no corresponding match is found then the vector will be empty.

Parameters: |id|: the capability id to search for

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

Returns the Bus Transaction Intiator (BTI) at a given index for the device.

Parameters: |index|: the BTI to request.

Errors: |ZX_ERR_OUT_OF_RANGE|: |index| was not 0.

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 get_device_info(&mut self, responder: Responder<GetDeviceInfo, ___T>)

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

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

async fn reset_device(&mut self, responder: Responder<ResetDevice, ___T>)

async fn ack_interrupt(&mut self, responder: Responder<AckInterrupt, ___T>)

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

async fn get_interrupt_modes( &mut self, responder: Responder<GetInterruptModes, ___T>, )

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

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

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

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

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

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

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

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

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

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

Implementors