Struct sam4l::flashcalw::FLASHCALW

pub struct FLASHCALW {
    registers: *mut FlashcalwRegisters,
    ahb_clock: Clock,
    hramc1_clock: Clock,
    pb_clock: Clock,
    client: Cell<Option<&'static Client<FLASHCALW>>>,
    current_state: Cell<FlashState>,
    buffer: TakeCell<'static, Sam4lPage>,
}

Fields

registers: *mut FlashcalwRegisters

ahb_clock: Clock

hramc1_clock: Clock

pb_clock: Clock

client: Cell<Option<&'static Client<FLASHCALW>>>

current_state: Cell<FlashState>

buffer: TakeCell<'static, Sam4lPage>

Methods

impl FLASHCALW

const fn new(
    base_addr: usize,
    ahb_clk: HSBClock,
    hramc1_clk: HSBClock,
    pb_clk: PBBClock
) -> FLASHCALW

fn invalidate_cache(&self)

Cache controlling functionality.

pub fn enable_picocache(&self, enable: bool)

pub fn enable_cache(&self)

Enable HCACHE

pub fn pico_enabled(&self) -> bool

fn read_register(&self, key: RegKey) -> u32

pub fn handle_interrupt(&self)

pub fn get_flash_size(&self) -> u32

FLASH properties.

pub fn get_page_count(&self) -> u32

pub fn get_page_count_per_region(&self) -> u32

pub fn get_page_region(&self, page_number: i32) -> u32

pub fn get_region_first_page_number(&self, region: u32) -> u32

fn get_wait_state(&self) -> u32

FLASHC Control

fn set_wait_state(&self, wait_state: u32)

fn enable_ws1_read_opt(&mut self, enable: bool)

fn set_flash_waitstate_and_readmode(
    &mut self,
    cpu_freq: u32,
    _ps_val: u32,
    _is_fwu_enabled: bool
)

pub fn enable_high_speed_flash(&self)

Configure high-speed flash mode. This is taken from the ASF code

fn is_ready_int_enabled(&self) -> bool

fn enable_ready_int(&self, enable: bool)

fn is_lock_error_int_enabled(&self) -> bool

fn enable_lock_error_int(&self, enable: bool)

fn is_prog_error_int_enabled(&self) -> bool

fn enable_prog_error_int(&self, enable: bool)

fn is_ecc_int_enabled(&self) -> bool

fn enable_ecc_int(&self, enable: bool)

pub fn is_ready(&self) -> bool

Flashcalw status

fn get_error_status(&self) -> u32

fn is_lock_error(&self) -> bool

fn is_programming_error(&self) -> bool

fn get_page_number(&self) -> u32

Flashcalw command control

pub fn issue_command(&self, command: FlashCMD, page_number: i32)

pub fn no_operation(&self)

Flashcalw global commands

pub fn erase_all(&self)

fn is_security_bit_active(&self) -> bool

FLASHCALW Protection Mechanisms

fn set_security_bit(&self)

pub fn is_page_region_locked(&self, page_number: u32) -> bool

pub fn is_region_locked(&self, region: u32) -> bool

pub fn lock_page_region(&self, page_number: i32, lock: bool)

fn lock_region(&self, region: u32, lock: bool)

fn clear_page_buffer(&self)

Flashcalw Access to Flash Pages

fn is_page_erased(&self) -> bool

fn quick_page_read(&self, page_number: i32) -> bool

fn flashcalw_erase_page(&self, page_number: i32)

fn flashcalw_write_page(&self, page_number: i32)

fn quick_user_page_read(&self) -> bool

There's a user_page that isn't contiguous with the rest of the flash. Currently it's not being used.

fn erase_user_page(&self, check: bool) -> bool

fn write_user_page(&self)

fn write_to_page_buffer(&self, pg_buff_addr: usize)

impl FLASHCALW

pub fn configure(&mut self)

pub fn get_page_size(&self) -> u32

pub fn get_number_pages(&self) -> u32

pub fn read_range(
    &self,
    address: usize,
    size: usize,
    buffer: &'static mut Sam4lPage
) -> ReturnCode

pub fn write_page(
    &self,
    page_num: i32,
    data: &'static mut Sam4lPage
) -> ReturnCode

pub fn erase_page(&self, page_num: i32) -> ReturnCode

Trait Implementations

impl<C: Client<Self>> HasClient<'static, C> for FLASHCALW

fn set_client(&self, client: &'static C)

Set the client for this flash peripheral. The client will be called when operations complete.

impl Flash for FLASHCALW

type Page = Sam4lPage

Type of a single flash page for the given implementation.

fn read_page(
    &self,
    page_number: usize,
    buf: &'static mut Self::Page
) -> ReturnCode

Read a page of flash into the buffer.

fn write_page(
    &self,
    page_number: usize,
    buf: &'static mut Self::Page
) -> ReturnCode

Write a page of flash from the buffer.

fn erase_page(&self, page_number: usize) -> ReturnCode

Erase a page of flash.