Struct capsules_extra::can::CanCapsule

pub struct CanCapsule<'a, Can: Can> { /* private fields */ }

Implementations

impl<'a, Can: Can> CanCapsule<'a, Can>

pub fn new( can: &'a Can, grant: Grant<App, UpcallCount<{ up_calls::COUNT }>, AllowRoCount<{ ro_allow::COUNT }>, AllowRwCount<{ rw_allow::COUNT }>>, can_tx: &'static mut [u8; 8], can_rx: &'static mut [u8; 8], ) -> CanCapsule<'a, Can>

pub fn process_send_command( &self, processid: ProcessId, id: Id, length: usize, ) -> Result<(), ErrorCode>

This function makes a copy of the buffer in the grant and sends it to the low-level hardware, in order for it to be sent on the bus.

pub fn is_valid_process(&self, processid: ProcessId) -> bool

Trait Implementations

impl<'a, Can: Can> ControllerClient for CanCapsule<'a, Can>

fn state_changed(&self, state: State)

The driver calls this function when the state of the CAN peripheral is changed.

fn enabled(&self, status: Result<(), ErrorCode>)

The driver calls this function when the peripheral has been successfully enabled. The driver must call this function and state_changed also, but must wait for this function to be called. If an error occurs, the state_changed callback might not be able to report it.

fn disabled(&self, status: Result<(), ErrorCode>)

The driver calls this function when the peripheral has been successfully disabled. The driver must call this function and state_changed also, but must wait for this function to be called. If an error occurs, the state_changed callback might not be able to report it.

impl<'a, Can: Can> ReceiveClient<{ can::STANDARD_CAN_PACKET_SIZE }> for CanCapsule<'a, Can>

fn message_received( &self, id: Id, buffer: &mut [u8; 8], _len: usize, status: Result<(), Error>, )

The driver calls this function when a new message has been received on the given FIFO.

fn stopped(&self, buffer: &'static mut [u8; 8])

The driver calls this function when the reception of messages has been stopped.

impl<'a, Can: Can> SyscallDriver for CanCapsule<'a, Can>

fn command( &self, command_num: usize, arg1: usize, arg2: usize, processid: ProcessId, ) -> CommandReturn

System call for a process to perform a short synchronous operation or start a long-running split-phase operation (whose completion is signaled with an upcall). Command 0 is a reserved command to detect if a peripheral system call driver is installed and must always return a CommandReturn::success.

fn allocate_grant(&self, process_id: ProcessId) -> Result<(), Error>

Request to allocate a capsule’s grant for a specific process.

fn allow_userspace_readable( &self, app: ProcessId, which: usize, slice: ReadWriteProcessBuffer, ) -> Result<ReadWriteProcessBuffer, (ReadWriteProcessBuffer, ErrorCode)>

System call for a process to pass a buffer (a UserspaceReadableProcessBuffer) to the kernel that the kernel can either read or write. The kernel calls this method only after it checks that the entire buffer is within memory the process can both read and write.

impl<'a, Can: Can> TransmitClient<{ can::STANDARD_CAN_PACKET_SIZE }> for CanCapsule<'a, Can>

fn transmit_complete( &self, status: Result<(), Error>, buffer: &'static mut [u8; 8], )

The driver calls this function when there is an update of the last message that was transmitted