Struct AtsamdMci

pub struct AtsamdMci { /* private fields */ }

Implementations

impl AtsamdMci

pub fn new(sdhc: SDHC0) -> AtsamdMci

pub fn reset(&mut self)

pub fn wait_busy(&mut self) -> Result<(), MciError>

pub fn set_speed(&mut self, speed: u32, prog_clock_mode: u8)

pub fn send_command_execute( &mut self, cmdr: u16, cmd: u32, arg: u32, ) -> Result<(), MciError>

Send a command

pub fn eistr_err(&mut self) -> Result<(), MciError>

pub fn loop_or_on_eistr_err<F: FnMut(&mut AtsamdMci) -> bool>( &mut self, f: F, ) -> Result<(), MciError>

Trait Implementations

impl Mci for AtsamdMci

fn send_clock(&mut self) -> Result<(), MciError>

Send 74 clock cycles on the line. Note: It is required after card plug and before card install.

fn init(&mut self) -> Result<(), MciError>

Initialize MCI low level driver.

fn send_command(&mut self, cmd: u32, arg: u32) -> Result<(), MciError>

fn deinit(&mut self) -> Result<(), MciError>

Deinitialize MCI low level driver.

fn select_device( &mut self, _slot: u8, clock: u32, bus_width: &BusWidth, high_speed: bool, ) -> Result<(), MciError>

Select a device and initialize it

fn deselect_device(&mut self, _slot: u8) -> Result<(), MciError>

Deselect device

fn get_bus_width(&mut self, slot: u8) -> Result<BusWidth, MciError>

Get the maximum bus width for a device

fn is_high_speed_capable(&mut self) -> Result<bool, MciError>

Whether the device is high speed capable

fn get_response(&mut self) -> Result<u32, MciError>

Get 32 bits response of last command

fn get_response128(&mut self) -> Result<[u32; 4], MciError>

Get 128 bits response of last command

fn adtc_start( &mut self, command: u32, argument: u32, block_size: u16, block_amount: u16, _access_in_blocks: bool, ) -> Result<(), MciError>

ADTC command start An ADTC (Addressed Data Transfer Commands) is used for R/W access

fn adtc_stop(&self, _command: u32, _argument: u32) -> Result<(), MciError>

ADTC command stop Send a command to stop an ADTC

fn read_word(&mut self) -> Result<(u32, u8), MciError>

Read a word on the wire

fn write_word(&mut self, val: u32) -> Result<bool, MciError>

Write a word on the wire

fn read_blocks( &mut self, destination: &mut [u8], number_of_blocks: u16, ) -> Result<bool, MciError>

Start a read block transfer on the line

fn write_blocks( &mut self, write_data: &[u8], number_of_blocks: u16, ) -> Result<bool, MciError>

Start a write block transfer on the line

fn wait_until_read_finished(&self) -> Result<(), MciError>

Wait until the end of reading the blocks

fn wait_until_write_finished(&self) -> Result<(), MciError>

Wait until the end of writing blocks