#![allow(clippy::missing_safety_doc)]
#![allow(clippy::identity_op)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::erasing_op)]
#[doc = "Programmable Fast Interrupt Controller."]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pfic {
ptr: *mut u8,
}
unsafe impl Send for Pfic {}
unsafe impl Sync for Pfic {}
impl Pfic {
#[inline(always)]
pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
Self { ptr: ptr as _ }
}
#[inline(always)]
pub const fn as_ptr(&self) -> *mut () {
self.ptr as _
}
#[doc = "Interrupt Status Register."]
#[inline(always)]
pub const fn isr1(self) -> crate::common::Reg<regs::Isr1, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
}
#[doc = "Interrupt Status Register."]
#[inline(always)]
pub const fn isr2(self) -> crate::common::Reg<regs::Isr2, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
}
#[doc = "Interrupt Status Register."]
#[inline(always)]
pub const fn isr3(self) -> crate::common::Reg<regs::Isr3, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
}
#[doc = "Interrupt Status Register."]
#[inline(always)]
pub const fn isr4(self) -> crate::common::Reg<regs::Isr4, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipr1(self) -> crate::common::Reg<regs::Ipr1, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x20usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipr2(self) -> crate::common::Reg<regs::Ipr2, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x24usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipr3(self) -> crate::common::Reg<regs::Ipr3, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x28usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipr4(self) -> crate::common::Reg<regs::Ipr4, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x2cusize) as _) }
}
#[doc = "Interrupt Priority Register."]
#[inline(always)]
pub const fn ithresdr(self) -> crate::common::Reg<regs::Ithresdr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x40usize) as _) }
}
#[doc = "Interrupt Config Register."]
#[inline(always)]
pub const fn cfgr(self) -> crate::common::Reg<regs::Cfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x48usize) as _) }
}
#[doc = "Interrupt Global Register."]
#[inline(always)]
pub const fn gisr(self) -> crate::common::Reg<regs::Gisr, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x4cusize) as _) }
}
#[doc = "ID Config Register."]
#[inline(always)]
pub const fn vtfidr(self) -> crate::common::Reg<regs::Vtfidr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x50usize) as _) }
}
#[doc = "Interrupt 0 address Register."]
#[inline(always)]
pub const fn vtfaddrr0(self) -> crate::common::Reg<regs::Vtfaddrr0, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x60usize) as _) }
}
#[doc = "Interrupt 1 address Register."]
#[inline(always)]
pub const fn vtfaddrr1(self) -> crate::common::Reg<regs::Vtfaddrr1, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x64usize) as _) }
}
#[doc = "Interrupt 2 address Register."]
#[inline(always)]
pub const fn vtfaddrr2(self) -> crate::common::Reg<regs::Vtfaddrr2, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x68usize) as _) }
}
#[doc = "Interrupt 3 address Register."]
#[inline(always)]
pub const fn vtfaddrr3(self) -> crate::common::Reg<regs::Vtfaddrr3, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x6cusize) as _) }
}
#[doc = "Interrupt Setting Register."]
#[inline(always)]
pub const fn ienr1(self) -> crate::common::Reg<regs::Ienr1, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0100usize) as _) }
}
#[doc = "Interrupt Setting Register."]
#[inline(always)]
pub const fn ienr2(self) -> crate::common::Reg<regs::Ienr2, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0104usize) as _) }
}
#[doc = "Interrupt Setting Register."]
#[inline(always)]
pub const fn ienr3(self) -> crate::common::Reg<regs::Ienr3, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0108usize) as _) }
}
#[doc = "Interrupt Setting Register."]
#[inline(always)]
pub const fn ienr4(self) -> crate::common::Reg<regs::Ienr4, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x010cusize) as _) }
}
#[doc = "Interrupt Clear Register."]
#[inline(always)]
pub const fn irer1(self) -> crate::common::Reg<regs::Irer1, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0180usize) as _) }
}
#[doc = "Interrupt Clear Register."]
#[inline(always)]
pub const fn irer2(self) -> crate::common::Reg<regs::Irer2, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0184usize) as _) }
}
#[doc = "Interrupt Clear Register."]
#[inline(always)]
pub const fn irer3(self) -> crate::common::Reg<regs::Irer3, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0188usize) as _) }
}
#[doc = "Interrupt Clear Register."]
#[inline(always)]
pub const fn irer4(self) -> crate::common::Reg<regs::Irer4, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x018cusize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipsr1(self) -> crate::common::Reg<regs::Ipsr1, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0200usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipsr2(self) -> crate::common::Reg<regs::Ipsr2, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0204usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipsr3(self) -> crate::common::Reg<regs::Ipsr3, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0208usize) as _) }
}
#[doc = "Interrupt Pending Register."]
#[inline(always)]
pub const fn ipsr4(self) -> crate::common::Reg<regs::Ipsr4, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x020cusize) as _) }
}
#[doc = "Interrupt Pending Clear Register."]
#[inline(always)]
pub const fn iprr1(self) -> crate::common::Reg<regs::Iprr1, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0280usize) as _) }
}
#[doc = "Interrupt Pending Clear Register."]
#[inline(always)]
pub const fn iprr2(self) -> crate::common::Reg<regs::Iprr2, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0284usize) as _) }
}
#[doc = "Interrupt Pending Clear Register."]
#[inline(always)]
pub const fn iprr3(self) -> crate::common::Reg<regs::Iprr3, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0288usize) as _) }
}
#[doc = "Interrupt Pending Clear Register."]
#[inline(always)]
pub const fn iprr4(self) -> crate::common::Reg<regs::Iprr4, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x028cusize) as _) }
}
#[doc = "Interrupt ACTIVE Register."]
#[inline(always)]
pub const fn iactr1(self) -> crate::common::Reg<regs::Iactr1, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0300usize) as _) }
}
#[doc = "Interrupt ACTIVE Register."]
#[inline(always)]
pub const fn iactr2(self) -> crate::common::Reg<regs::Iactr2, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0304usize) as _) }
}
#[doc = "Interrupt ACTIVE Register."]
#[inline(always)]
pub const fn iactr3(self) -> crate::common::Reg<regs::Iactr3, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0308usize) as _) }
}
#[doc = "Interrupt ACTIVE Register."]
#[inline(always)]
pub const fn iactr4(self) -> crate::common::Reg<regs::Iactr4, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x030cusize) as _) }
}
#[doc = "Interrupt Priority Register."]
#[inline(always)]
pub const fn iprior(self, n: usize) -> crate::common::Reg<u8, crate::common::RW> {
assert!(n < 64usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0400usize + n * 1usize) as _) }
}
#[doc = "System Control Register."]
#[inline(always)]
pub const fn sctlr(self) -> crate::common::Reg<regs::Sctlr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0d10usize) as _) }
}
}
pub mod regs {
#[doc = "Interrupt Config Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfgr(pub u32);
impl Cfgr {
#[doc = "RESETSYS."]
#[inline(always)]
pub const fn resetsys(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "RESETSYS."]
#[inline(always)]
pub fn set_resetsys(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "KEYCODE."]
#[inline(always)]
pub const fn keycode(&self) -> super::vals::Keycode {
let val = (self.0 >> 16usize) & 0xffff;
super::vals::Keycode::from_bits(val as u16)
}
#[doc = "KEYCODE."]
#[inline(always)]
pub fn set_keycode(&mut self, val: super::vals::Keycode) {
self.0 =
(self.0 & !(0xffff << 16usize)) | (((val.to_bits() as u32) & 0xffff) << 16usize);
}
}
impl Default for Cfgr {
#[inline(always)]
fn default() -> Cfgr {
Cfgr(0)
}
}
#[doc = "Interrupt Global Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Gisr(pub u32);
impl Gisr {
#[doc = "NESTSTA."]
#[inline(always)]
pub const fn neststa(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "NESTSTA."]
#[inline(always)]
pub fn set_neststa(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
#[doc = "GACTSTA."]
#[inline(always)]
pub const fn gactsta(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "GACTSTA."]
#[inline(always)]
pub fn set_gactsta(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "GPENDSTA."]
#[inline(always)]
pub const fn gpendsta(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "GPENDSTA."]
#[inline(always)]
pub fn set_gpendsta(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
}
impl Default for Gisr {
#[inline(always)]
fn default() -> Gisr {
Gisr(0)
}
}
#[doc = "Interrupt ACTIVE Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iactr1(pub u32);
impl Iactr1 {
#[doc = "IACTS."]
#[inline(always)]
pub const fn iacts2_3(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "IACTS."]
#[inline(always)]
pub fn set_iacts2_3(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "IACTS."]
#[inline(always)]
pub const fn iacts12_31(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "IACTS."]
#[inline(always)]
pub fn set_iacts12_31(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Iactr1 {
#[inline(always)]
fn default() -> Iactr1 {
Iactr1(0)
}
}
#[doc = "Interrupt ACTIVE Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iactr2(pub u32);
impl Iactr2 {
#[doc = "IACTS."]
#[inline(always)]
pub const fn iacts(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "IACTS."]
#[inline(always)]
pub fn set_iacts(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Iactr2 {
#[inline(always)]
fn default() -> Iactr2 {
Iactr2(0)
}
}
#[doc = "Interrupt ACTIVE Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iactr3(pub u32);
impl Iactr3 {
#[doc = "IACTS."]
#[inline(always)]
pub const fn iacts(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "IACTS."]
#[inline(always)]
pub fn set_iacts(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Iactr3 {
#[inline(always)]
fn default() -> Iactr3 {
Iactr3(0)
}
}
#[doc = "Interrupt ACTIVE Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iactr4(pub u32);
impl Iactr4 {
#[doc = "IACTS."]
#[inline(always)]
pub const fn iacts(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "IACTS."]
#[inline(always)]
pub fn set_iacts(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Iactr4 {
#[inline(always)]
fn default() -> Iactr4 {
Iactr4(0)
}
}
#[doc = "Interrupt Setting Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ienr1(pub u32);
impl Ienr1 {
#[doc = "INTEN."]
#[inline(always)]
pub const fn inten(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "INTEN."]
#[inline(always)]
pub fn set_inten(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Ienr1 {
#[inline(always)]
fn default() -> Ienr1 {
Ienr1(0)
}
}
#[doc = "Interrupt Setting Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ienr2(pub u32);
impl Ienr2 {
#[doc = "INTEN."]
#[inline(always)]
pub const fn inten(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "INTEN."]
#[inline(always)]
pub fn set_inten(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ienr2 {
#[inline(always)]
fn default() -> Ienr2 {
Ienr2(0)
}
}
#[doc = "Interrupt Setting Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ienr3(pub u32);
impl Ienr3 {
#[doc = "INTEN."]
#[inline(always)]
pub const fn inten(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "INTEN."]
#[inline(always)]
pub fn set_inten(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ienr3 {
#[inline(always)]
fn default() -> Ienr3 {
Ienr3(0)
}
}
#[doc = "Interrupt Setting Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ienr4(pub u32);
impl Ienr4 {
#[doc = "INTEN."]
#[inline(always)]
pub const fn inten(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "INTEN."]
#[inline(always)]
pub fn set_inten(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ienr4 {
#[inline(always)]
fn default() -> Ienr4 {
Ienr4(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipr1(pub u32);
impl Ipr1 {
#[doc = "PENDSTA."]
#[inline(always)]
pub const fn pendsta2_3(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "PENDSTA."]
#[inline(always)]
pub fn set_pendsta2_3(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "PENDSTA."]
#[inline(always)]
pub const fn pendsta12_31(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "PENDSTA."]
#[inline(always)]
pub fn set_pendsta12_31(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Ipr1 {
#[inline(always)]
fn default() -> Ipr1 {
Ipr1(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipr2(pub u32);
impl Ipr2 {
#[doc = "PENDSTA."]
#[inline(always)]
pub const fn pendsta(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDSTA."]
#[inline(always)]
pub fn set_pendsta(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ipr2 {
#[inline(always)]
fn default() -> Ipr2 {
Ipr2(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipr3(pub u32);
impl Ipr3 {
#[doc = "PENDSTA."]
#[inline(always)]
pub const fn pendsta(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDSTA."]
#[inline(always)]
pub fn set_pendsta(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ipr3 {
#[inline(always)]
fn default() -> Ipr3 {
Ipr3(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipr4(pub u32);
impl Ipr4 {
#[doc = "PENDSTA."]
#[inline(always)]
pub const fn pendsta(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "PENDSTA."]
#[inline(always)]
pub fn set_pendsta(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ipr4 {
#[inline(always)]
fn default() -> Ipr4 {
Ipr4(0)
}
}
#[doc = "Interrupt Pending Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iprr1(pub u32);
impl Iprr1 {
#[doc = "PENDRESET."]
#[inline(always)]
pub const fn pendreset2_3(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "PENDRESET."]
#[inline(always)]
pub fn set_pendreset2_3(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "PENDRESET."]
#[inline(always)]
pub const fn pendreset12_31(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "PENDRESET."]
#[inline(always)]
pub fn set_pendreset12_31(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Iprr1 {
#[inline(always)]
fn default() -> Iprr1 {
Iprr1(0)
}
}
#[doc = "Interrupt Pending Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iprr2(pub u32);
impl Iprr2 {
#[doc = "PENDRESET."]
#[inline(always)]
pub const fn pendreset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDRESET."]
#[inline(always)]
pub fn set_pendreset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Iprr2 {
#[inline(always)]
fn default() -> Iprr2 {
Iprr2(0)
}
}
#[doc = "Interrupt Pending Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iprr3(pub u32);
impl Iprr3 {
#[doc = "PENDRESET."]
#[inline(always)]
pub const fn pendreset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDRESET."]
#[inline(always)]
pub fn set_pendreset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Iprr3 {
#[inline(always)]
fn default() -> Iprr3 {
Iprr3(0)
}
}
#[doc = "Interrupt Pending Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Iprr4(pub u32);
impl Iprr4 {
#[doc = "PENDRESET."]
#[inline(always)]
pub const fn pendreset(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "PENDRESET."]
#[inline(always)]
pub fn set_pendreset(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Iprr4 {
#[inline(always)]
fn default() -> Iprr4 {
Iprr4(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipsr1(pub u32);
impl Ipsr1 {
#[doc = "PENDSET."]
#[inline(always)]
pub const fn pendset2_3(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "PENDSET."]
#[inline(always)]
pub fn set_pendset2_3(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "PENDSET."]
#[inline(always)]
pub const fn pendset12_31(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "PENDSET."]
#[inline(always)]
pub fn set_pendset12_31(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Ipsr1 {
#[inline(always)]
fn default() -> Ipsr1 {
Ipsr1(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipsr2(pub u32);
impl Ipsr2 {
#[doc = "PENDSET."]
#[inline(always)]
pub const fn pendset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDSET."]
#[inline(always)]
pub fn set_pendset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ipsr2 {
#[inline(always)]
fn default() -> Ipsr2 {
Ipsr2(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipsr3(pub u32);
impl Ipsr3 {
#[doc = "PENDSET."]
#[inline(always)]
pub const fn pendset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "PENDSET."]
#[inline(always)]
pub fn set_pendset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ipsr3 {
#[inline(always)]
fn default() -> Ipsr3 {
Ipsr3(0)
}
}
#[doc = "Interrupt Pending Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ipsr4(pub u32);
impl Ipsr4 {
#[doc = "PENDSET."]
#[inline(always)]
pub const fn pendset(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "PENDSET."]
#[inline(always)]
pub fn set_pendset(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ipsr4 {
#[inline(always)]
fn default() -> Ipsr4 {
Ipsr4(0)
}
}
#[doc = "Interrupt Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Irer1(pub u32);
impl Irer1 {
#[doc = "INTRSET."]
#[inline(always)]
pub const fn intrset(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "INTRSET."]
#[inline(always)]
pub fn set_intrset(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Irer1 {
#[inline(always)]
fn default() -> Irer1 {
Irer1(0)
}
}
#[doc = "Interrupt Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Irer2(pub u32);
impl Irer2 {
#[doc = "INTRSET."]
#[inline(always)]
pub const fn intrset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "INTRSET."]
#[inline(always)]
pub fn set_intrset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Irer2 {
#[inline(always)]
fn default() -> Irer2 {
Irer2(0)
}
}
#[doc = "Interrupt Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Irer3(pub u32);
impl Irer3 {
#[doc = "INTRSET."]
#[inline(always)]
pub const fn intrset(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "INTRSET."]
#[inline(always)]
pub fn set_intrset(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Irer3 {
#[inline(always)]
fn default() -> Irer3 {
Irer3(0)
}
}
#[doc = "Interrupt Clear Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Irer4(pub u32);
impl Irer4 {
#[doc = "INTRSET."]
#[inline(always)]
pub const fn intrset(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "INTRSET."]
#[inline(always)]
pub fn set_intrset(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Irer4 {
#[inline(always)]
fn default() -> Irer4 {
Irer4(0)
}
}
#[doc = "Interrupt Status Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr1(pub u32);
impl Isr1 {
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub const fn intensta2_3(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub fn set_intensta2_3(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub const fn intensta12_31(&self) -> u32 {
let val = (self.0 >> 12usize) & 0x000f_ffff;
val as u32
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub fn set_intensta12_31(&mut self, val: u32) {
self.0 =
(self.0 & !(0x000f_ffff << 12usize)) | (((val as u32) & 0x000f_ffff) << 12usize);
}
}
impl Default for Isr1 {
#[inline(always)]
fn default() -> Isr1 {
Isr1(0)
}
}
#[doc = "Interrupt Status Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr2(pub u32);
impl Isr2 {
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub const fn intensta(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub fn set_intensta(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Isr2 {
#[inline(always)]
fn default() -> Isr2 {
Isr2(0)
}
}
#[doc = "Interrupt Status Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr3(pub u32);
impl Isr3 {
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub const fn intensta(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub fn set_intensta(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Isr3 {
#[inline(always)]
fn default() -> Isr3 {
Isr3(0)
}
}
#[doc = "Interrupt Status Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr4(pub u32);
impl Isr4 {
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub const fn intensta(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Interrupt ID Status."]
#[inline(always)]
pub fn set_intensta(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Isr4 {
#[inline(always)]
fn default() -> Isr4 {
Isr4(0)
}
}
#[doc = "Interrupt Priority Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ithresdr(pub u32);
impl Ithresdr {
#[doc = "THRESHOLD."]
#[inline(always)]
pub const fn threshold(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "THRESHOLD."]
#[inline(always)]
pub fn set_threshold(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ithresdr {
#[inline(always)]
fn default() -> Ithresdr {
Ithresdr(0)
}
}
#[doc = "System Control Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sctlr(pub u32);
impl Sctlr {
#[doc = "SLEEPONEXIT."]
#[inline(always)]
pub const fn sleeponexit(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "SLEEPONEXIT."]
#[inline(always)]
pub fn set_sleeponexit(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "SLEEPDEEP."]
#[inline(always)]
pub const fn sleepdeep(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "SLEEPDEEP."]
#[inline(always)]
pub fn set_sleepdeep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "WFITOWFE."]
#[inline(always)]
pub const fn wfitowfe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "WFITOWFE."]
#[inline(always)]
pub fn set_wfitowfe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "SEVONPEND."]
#[inline(always)]
pub const fn sevonpend(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "SEVONPEND."]
#[inline(always)]
pub fn set_sevonpend(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "SETEVENT."]
#[inline(always)]
pub const fn setevent(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "SETEVENT."]
#[inline(always)]
pub fn set_setevent(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "SYSRESET."]
#[inline(always)]
pub const fn sysreset(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "SYSRESET."]
#[inline(always)]
pub fn set_sysreset(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Sctlr {
#[inline(always)]
fn default() -> Sctlr {
Sctlr(0)
}
}
#[doc = "Interrupt 0 address Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Vtfaddrr0(pub u32);
impl Vtfaddrr0 {
#[doc = "VTF0EN."]
#[inline(always)]
pub const fn vtf0en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "VTF0EN."]
#[inline(always)]
pub fn set_vtf0en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "ADDR0."]
#[inline(always)]
pub const fn addr0(&self) -> u32 {
let val = (self.0 >> 1usize) & 0x7fff_ffff;
val as u32
}
#[doc = "ADDR0."]
#[inline(always)]
pub fn set_addr0(&mut self, val: u32) {
self.0 = (self.0 & !(0x7fff_ffff << 1usize)) | (((val as u32) & 0x7fff_ffff) << 1usize);
}
}
impl Default for Vtfaddrr0 {
#[inline(always)]
fn default() -> Vtfaddrr0 {
Vtfaddrr0(0)
}
}
#[doc = "Interrupt 1 address Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Vtfaddrr1(pub u32);
impl Vtfaddrr1 {
#[doc = "VTF1EN."]
#[inline(always)]
pub const fn vtf1en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "VTF1EN."]
#[inline(always)]
pub fn set_vtf1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "ADDR1."]
#[inline(always)]
pub const fn addr1(&self) -> u32 {
let val = (self.0 >> 1usize) & 0x7fff_ffff;
val as u32
}
#[doc = "ADDR1."]
#[inline(always)]
pub fn set_addr1(&mut self, val: u32) {
self.0 = (self.0 & !(0x7fff_ffff << 1usize)) | (((val as u32) & 0x7fff_ffff) << 1usize);
}
}
impl Default for Vtfaddrr1 {
#[inline(always)]
fn default() -> Vtfaddrr1 {
Vtfaddrr1(0)
}
}
#[doc = "Interrupt 2 address Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Vtfaddrr2(pub u32);
impl Vtfaddrr2 {
#[doc = "VTF2EN."]
#[inline(always)]
pub const fn vtf2en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "VTF2EN."]
#[inline(always)]
pub fn set_vtf2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "ADDR2."]
#[inline(always)]
pub const fn addr2(&self) -> u32 {
let val = (self.0 >> 1usize) & 0x7fff_ffff;
val as u32
}
#[doc = "ADDR2."]
#[inline(always)]
pub fn set_addr2(&mut self, val: u32) {
self.0 = (self.0 & !(0x7fff_ffff << 1usize)) | (((val as u32) & 0x7fff_ffff) << 1usize);
}
}
impl Default for Vtfaddrr2 {
#[inline(always)]
fn default() -> Vtfaddrr2 {
Vtfaddrr2(0)
}
}
#[doc = "Interrupt 3 address Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Vtfaddrr3(pub u32);
impl Vtfaddrr3 {
#[doc = "VTF3EN."]
#[inline(always)]
pub const fn vtf3en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "VTF3EN."]
#[inline(always)]
pub fn set_vtf3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "ADDR3."]
#[inline(always)]
pub const fn addr3(&self) -> u32 {
let val = (self.0 >> 1usize) & 0x7fff_ffff;
val as u32
}
#[doc = "ADDR3."]
#[inline(always)]
pub fn set_addr3(&mut self, val: u32) {
self.0 = (self.0 & !(0x7fff_ffff << 1usize)) | (((val as u32) & 0x7fff_ffff) << 1usize);
}
}
impl Default for Vtfaddrr3 {
#[inline(always)]
fn default() -> Vtfaddrr3 {
Vtfaddrr3(0)
}
}
#[doc = "ID Config Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Vtfidr(pub u32);
impl Vtfidr {
#[doc = "VTFID0."]
#[inline(always)]
pub const fn vtfid0(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "VTFID0."]
#[inline(always)]
pub fn set_vtfid0(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
#[doc = "VTFID1."]
#[inline(always)]
pub const fn vtfid1(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "VTFID1."]
#[inline(always)]
pub fn set_vtfid1(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
}
#[doc = "VTFID2."]
#[inline(always)]
pub const fn vtfid2(&self) -> u8 {
let val = (self.0 >> 16usize) & 0xff;
val as u8
}
#[doc = "VTFID2."]
#[inline(always)]
pub fn set_vtfid2(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
}
#[doc = "VTFID3."]
#[inline(always)]
pub const fn vtfid3(&self) -> u8 {
let val = (self.0 >> 24usize) & 0xff;
val as u8
}
#[doc = "VTFID3."]
#[inline(always)]
pub fn set_vtfid3(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 24usize)) | (((val as u32) & 0xff) << 24usize);
}
}
impl Default for Vtfidr {
#[inline(always)]
fn default() -> Vtfidr {
Vtfidr(0)
}
}
}
pub mod vals {
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct Keycode(pub u16);
impl Keycode {
#[doc = "NMI and EXC key."]
pub const KEY2: Self = Self(0xbcaf);
#[doc = "System Reset key."]
pub const KEY3: Self = Self(0xbeef);
#[doc = "HWSTK and NEST key."]
pub const KEY1: Self = Self(0xfa05);
}
impl Keycode {
pub const fn from_bits(val: u16) -> Keycode {
Self(val & 0xffff)
}
pub const fn to_bits(self) -> u16 {
self.0
}
}
impl From<u16> for Keycode {
#[inline(always)]
fn from(val: u16) -> Keycode {
Keycode::from_bits(val)
}
}
impl From<Keycode> for u16 {
#[inline(always)]
fn from(val: Keycode) -> u16 {
Keycode::to_bits(val)
}
}
}