# lib.rs - source
Source of the Rust file `/home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/bare-metal-0.2.5/src/lib.rs`.
Keywords: rust, rustlang, rust-lang

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101

    //! Abstractions common to bare metal systems

    #![deny(missing_docs)]
    #![deny(warnings)]
    #![no_std]

    use core::cell::UnsafeCell;

    /// A peripheral
    #[derive(Debug)]
    pub struct Peripheral<T>
    where
        T: 'static,
    {
        address: *mut T,
    }

    impl<T> Peripheral<T> {
        /// Creates a new peripheral
        ///
        /// `address` is the base address of the register block
        pub const unsafe fn new(address: usize) -> Self {
            Peripheral {
                address: address as *mut T,
            }
        }

        /// Borrows the peripheral for the duration of a critical section
        pub fn borrow<'cs>(&self, _ctxt: &'cs CriticalSection) -> &'cs T {
            unsafe { &*self.get() }
        }

        /// Returns a pointer to the register block
        pub fn get(&self) -> *mut T {
            self.address as *mut T
        }
    }

    /// Critical section token
    ///
    /// Indicates that you are executing code within a critical section
    pub struct CriticalSection {
        _0: (),
    }

    impl CriticalSection {
        /// Creates a critical section token
        ///
        /// This method is meant to be used to create safe abstractions rather than
        /// meant to be directly used in applications.
        pub unsafe fn new() -> Self {
            CriticalSection { _0: () }
        }
    }

    /// A "mutex" based on critical sections
    ///
    /// # Safety
    ///
    /// **This Mutex is only safe on single-core systems.**
    ///
    /// On multi-core systems, a `CriticalSection` **is not sufficient** to ensure exclusive access.
    pub struct Mutex<T> {
        inner: UnsafeCell<T>,
    }

    impl<T> Mutex<T> {
        /// Creates a new mutex
        pub const fn new(value: T) -> Self {
            Mutex {
                inner: UnsafeCell::new(value),
            }
        }
    }

    impl<T> Mutex<T> {
        /// Borrows the data for the duration of the critical section
        pub fn borrow<'cs>(&'cs self, _cs: &'cs CriticalSection) -> &'cs T {
            unsafe { &*self.inner.get() }
        }
    }

    /// ``` compile_fail
    /// fn bad(cs: &bare_metal::CriticalSection) -> &u32 {
    ///     let x = bare_metal::Mutex::new(42u32);
    ///     x.borrow(cs)
    /// }
    /// ```
    #[allow(dead_code)]
    const GH_6: () = ();

    /// Interrupt number
    pub unsafe trait Nr {
        /// Returns the number associated with an interrupt
        fn nr(&self) -> u8;
    }

    // NOTE A `Mutex` can be used as a channel so the protected data must be `Send`
    // to prevent sending non-Sendable stuff (e.g. access tokens) across different
    // execution contexts (e.g. interrupts)
    unsafe impl<T> Sync for Mutex<T> where T: Send {}