      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
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121

    #[allow(unused_macros)]
    macro_rules! rsr {
        ($R:ident) => {
            impl super::super::sealed::Rsr for $R {
                unsafe fn __rsr(&self) -> u32 {
                    let r: u32;
                    asm!(concat!("mrs $0,", stringify!($R)) : "=r"(r) : : : "volatile");
                    r
                }
            }
        };
    }

    #[allow(unused_macros)]
    macro_rules! rsrp {
        ($R:ident) => {
            impl super::super::sealed::Rsrp for $R {
                unsafe fn __rsrp(&self) -> *const u8 {
                    let r: *const u8;
                    asm!(concat!("mrs $0,", stringify!($R)) : "=r"(r) : : : "volatile");
                    r
                }
            }
        };
    }

    #[allow(unused_macros)]
    macro_rules! wsr {
        ($R:ident) => {
            impl super::super::sealed::Wsr for $R {
                unsafe fn __wsr(&self, value: u32) {
                    asm!(concat!("msr ", stringify!($R), ",$0") : : "r"(value) : : "volatile");
                }
            }
        };
    }

    #[allow(unused_macros)]
    macro_rules! wsrp {
        ($R:ident) => {
            impl super::super::sealed::Wsrp for $R {
                unsafe fn __wsrp(&self, value: *const u8) {
                    asm!(concat!("msr ", stringify!($R), ",$0") : : "r"(value) : : "volatile");
                }
            }
        };
    }

    #[cfg(target_feature = "mclass")]
    mod v6m;

    #[cfg(target_feature = "mclass")]
    pub use self::v6m::*;

    #[cfg(all(target_feature = "v7", target_feature = "mclass"))]
    mod v7m;

    #[cfg(all(target_feature = "v7", target_feature = "mclass"))]
    pub use self::v7m::*;

    #[cfg(not(target_arch = "aarch64"))]
    mod aarch32;

    #[cfg(not(target_arch = "aarch64"))]
    pub use self::aarch32::*;

    /// Reads a 32-bit system register
    #[inline(always)]
    pub unsafe fn __rsr<R>(reg: R) -> u32
    where
        R: super::sealed::Rsr,
    {
        reg.__rsr()
    }

    /// Reads a 64-bit system register
    #[cfg(target_arch = "aarch64")]
    #[inline(always)]
    pub unsafe fn __rsr64<R>(reg: R) -> u64
    where
        R: super::sealed::Rsr64,
    {
        reg.__rsr64()
    }

    /// Reads a system register containing an address
    #[inline(always)]
    pub unsafe fn __rsrp<R>(reg: R) -> *const u8
    where
        R: super::sealed::Rsrp,
    {
        reg.__rsrp()
    }

    /// Writes a 32-bit system register
    #[inline(always)]
    pub unsafe fn __wsr<R>(reg: R, value: u32)
    where
        R: super::sealed::Wsr,
    {
        reg.__wsr(value)
    }

    /// Writes a 64-bit system register
    #[cfg(target_arch = "aarch64")]
    #[inline(always)]
    pub unsafe fn __wsr64<R>(reg: R, value: u64)
    where
        R: super::sealed::Wsr64,
    {
        reg.__wsr64(value)
    }

    /// Writes a system register containing an address
    #[inline(always)]
    pub unsafe fn __wsrp<R>(reg: R, value: *const u8)
    where
        R: super::sealed::Wsrp,
    {
        reg.__wsrp(value)
    }