Trait drone_cortexm::reg::field::RegField

pub trait RegField<T>: Token + Sync where
    T: RegTag, {
    type Reg: Reg<T>;
    type URegField: RegField<Urt>;
    type SRegField: RegField<Srt>;
    type CRegField: RegField<Crt>;

    pub const OFFSET: usize;
    pub const WIDTH: usize;
    pub fn into_unsync(self) -> Self
    where
        Self: RegField<Urt>,
    { ... }
    pub fn into_sync(self) -> Self
    where
        Self: RegField<Srt>,
    { ... }
    pub fn into_copy(self) -> Self::CRegField
    where
        T: RegAtomic,
    { ... }
    pub fn as_sync(&self) -> &Self::SRegField
    where
        T: RegAtomic,
    { ... }
}

The base trait for a field token of a memory-mapped register.

Associated Types

type Reg: Reg<T>

Parent register token.

type URegField: RegField<Urt>

Corresponding unsynchronized register field token.

type SRegField: RegField<Srt>

Corresponding synchronized register field token.

type CRegField: RegField<Crt>

Corresponding copyable register field token.

Loading content...

Associated Constants

pub const OFFSET: usize

The offset of the field inside the parent register.

pub const WIDTH: usize

The bit-width of the field.

Loading content...

Provided methods

pub fn into_unsync(self) -> Self where
    Self: RegField<Urt>, 

Converts into unsynchronized register field token.

pub fn into_sync(self) -> Self where
    Self: RegField<Srt>, 

Converts into synchronized register field token.

pub fn into_copy(self) -> Self::CRegField where
    T: RegAtomic, 

Converts into copyable register field token.

pub fn as_sync(&self) -> &Self::SRegField where
    T: RegAtomic, 

Returns a reference to the synchronized field token.

Loading content...

Implementors

impl<_T> RegField<_T> for Cyccnt<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Cyccnt<Urt>

type SRegField = Cyccnt<Srt>

type CRegField = Cyccnt<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Unlock<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Unlock<Urt>

type SRegField = Unlock<Srt>

type CRegField = Unlock<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Busy<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Busy<Urt>

type SRegField = Busy<Srt>

type CRegField = Busy<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Gtsfreq<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Gtsfreq<Urt>

type SRegField = Gtsfreq<Srt>

type CRegField = Gtsfreq<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Itmena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Itmena<Urt>

type SRegField = Itmena<Srt>

type CRegField = Itmena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Swoena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Swoena<Urt>

type SRegField = Swoena<Srt>

type CRegField = Swoena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Syncena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Syncena<Urt>

type SRegField = Syncena<Srt>

type CRegField = Syncena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for TraceBusID<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = TraceBusID<Urt>

type SRegField = TraceBusID<Srt>

type CRegField = TraceBusID<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Tsena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Tsena<Urt>

type SRegField = Tsena<Srt>

type CRegField = Tsena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Tsprescale<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Tsprescale<Urt>

type SRegField = Tsprescale<Srt>

type CRegField = Tsprescale<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Txena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Txena<Urt>

type SRegField = Txena<Srt>

type CRegField = Txena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Privmask<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Privmask<Urt>

type SRegField = Privmask<Srt>

type CRegField = Privmask<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Impdef<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Impdef<Urt>

type SRegField = Impdef<Srt>

type CRegField = Impdef<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Endianess<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Endianess<Urt>

type SRegField = Endianess<Srt>

type CRegField = Endianess<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Prigroup<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Prigroup<Urt>

type SRegField = Prigroup<Srt>

type CRegField = Prigroup<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Sysresetreq<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Sysresetreq<Urt>

type SRegField = Sysresetreq<Srt>

type CRegField = Sysresetreq<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vectclractive<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vectclractive<Urt>

type SRegField = Vectclractive<Srt>

type CRegField = Vectclractive<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vectkey<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vectkey<Urt>

type SRegField = Vectkey<Srt>

type CRegField = Vectkey<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vectreset<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vectreset<Urt>

type SRegField = Vectreset<Srt>

type CRegField = Vectreset<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for drone_cortexm::map::reg::scb::bfar::Address<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Address<Urt>

type SRegField = Address<Srt>

type CRegField = Address<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Bfarvalid<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Bfarvalid<Urt>

type SRegField = Bfarvalid<Srt>

type CRegField = Bfarvalid<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Ibuserr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Ibuserr<Urt>

type SRegField = Ibuserr<Srt>

type CRegField = Ibuserr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Impreciserr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Impreciserr<Urt>

type SRegField = Impreciserr<Srt>

type CRegField = Impreciserr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Lsperr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Lsperr<Urt>

type SRegField = Lsperr<Srt>

type CRegField = Lsperr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Preciserr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Preciserr<Urt>

type SRegField = Preciserr<Srt>

type CRegField = Preciserr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Stkerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Stkerr<Urt>

type SRegField = Stkerr<Srt>

type CRegField = Stkerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Unstkerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Unstkerr<Urt>

type SRegField = Unstkerr<Srt>

type CRegField = Unstkerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Bfhfnmign<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Bfhfnmign<Urt>

type SRegField = Bfhfnmign<Srt>

type CRegField = Bfhfnmign<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Div0Trp<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Div0Trp<Urt>

type SRegField = Div0Trp<Srt>

type CRegField = Div0Trp<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Nonbasethrdena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Nonbasethrdena<Urt>

type SRegField = Nonbasethrdena<Srt>

type CRegField = Nonbasethrdena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Stkalign<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Stkalign<Urt>

type SRegField = Stkalign<Srt>

type CRegField = Stkalign<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for UnalignTrp<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = UnalignTrp<Urt>

type SRegField = UnalignTrp<Srt>

type CRegField = UnalignTrp<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Usersetmpend<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Usersetmpend<Urt>

type SRegField = Usersetmpend<Srt>

type CRegField = Usersetmpend<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Architecture<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Architecture<Urt>

type SRegField = Architecture<Srt>

type CRegField = Architecture<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Implementer<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Implementer<Urt>

type SRegField = Implementer<Srt>

type CRegField = Implementer<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Partno<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Partno<Urt>

type SRegField = Partno<Srt>

type CRegField = Partno<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Revision<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Revision<Urt>

type SRegField = Revision<Srt>

type CRegField = Revision<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Variant<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Variant<Urt>

type SRegField = Variant<Srt>

type CRegField = Variant<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for MonEn<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = MonEn<Urt>

type SRegField = MonEn<Srt>

type CRegField = MonEn<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for MonPend<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = MonPend<Urt>

type SRegField = MonPend<Srt>

type CRegField = MonPend<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for MonReq<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = MonReq<Urt>

type SRegField = MonReq<Srt>

type CRegField = MonReq<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for MonStep<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = MonStep<Urt>

type SRegField = MonStep<Srt>

type CRegField = MonStep<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Trcena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Trcena<Urt>

type SRegField = Trcena<Srt>

type CRegField = Trcena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcBuserr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcBuserr<Urt>

type SRegField = VcBuserr<Srt>

type CRegField = VcBuserr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcChkerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcChkerr<Urt>

type SRegField = VcChkerr<Srt>

type CRegField = VcChkerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcCorereset<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcCorereset<Urt>

type SRegField = VcCorereset<Srt>

type CRegField = VcCorereset<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcHarderr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcHarderr<Urt>

type SRegField = VcHarderr<Srt>

type CRegField = VcHarderr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcInterr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcInterr<Urt>

type SRegField = VcInterr<Srt>

type CRegField = VcInterr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcMmerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcMmerr<Urt>

type SRegField = VcMmerr<Srt>

type CRegField = VcMmerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcNocperr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcNocperr<Urt>

type SRegField = VcNocperr<Srt>

type CRegField = VcNocperr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for VcStaterr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = VcStaterr<Urt>

type SRegField = VcStaterr<Srt>

type CRegField = VcStaterr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Bkpt<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Bkpt<Urt>

type SRegField = Bkpt<Srt>

type CRegField = Bkpt<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Dwttrap<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Dwttrap<Urt>

type SRegField = Dwttrap<Srt>

type CRegField = Dwttrap<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for External<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = External<Urt>

type SRegField = External<Srt>

type CRegField = External<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Halted<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Halted<Urt>

type SRegField = Halted<Srt>

type CRegField = Halted<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vcatch<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vcatch<Urt>

type SRegField = Vcatch<Srt>

type CRegField = Vcatch<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Debugevt<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Debugevt<Urt>

type SRegField = Debugevt<Srt>

type CRegField = Debugevt<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Forced<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Forced<Urt>

type SRegField = Forced<Srt>

type CRegField = Forced<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vecttbl<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vecttbl<Urt>

type SRegField = Vecttbl<Srt>

type CRegField = Vecttbl<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Isrpending<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Isrpending<Urt>

type SRegField = Isrpending<Srt>

type CRegField = Isrpending<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Nmipendset<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Nmipendset<Urt>

type SRegField = Nmipendset<Srt>

type CRegField = Nmipendset<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Pendstclr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Pendstclr<Urt>

type SRegField = Pendstclr<Srt>

type CRegField = Pendstclr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Pendstset<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Pendstset<Urt>

type SRegField = Pendstset<Srt>

type CRegField = Pendstset<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Pendsvclr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Pendsvclr<Urt>

type SRegField = Pendsvclr<Srt>

type CRegField = Pendsvclr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Pendsvset<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Pendsvset<Urt>

type SRegField = Pendsvset<Srt>

type CRegField = Pendsvset<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Rettobase<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Rettobase<Urt>

type SRegField = Rettobase<Srt>

type CRegField = Rettobase<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vectactive<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vectactive<Urt>

type SRegField = Vectactive<Srt>

type CRegField = Vectactive<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Vectpending<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Vectpending<Urt>

type SRegField = Vectpending<Srt>

type CRegField = Vectpending<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for drone_cortexm::map::reg::scb::mmfar::Address<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Address<Urt>

type SRegField = Address<Srt>

type CRegField = Address<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Daccviol<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Daccviol<Urt>

type SRegField = Daccviol<Srt>

type CRegField = Daccviol<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Iaccviol<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Iaccviol<Urt>

type SRegField = Iaccviol<Srt>

type CRegField = Iaccviol<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Mlsperr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Mlsperr<Urt>

type SRegField = Mlsperr<Srt>

type CRegField = Mlsperr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Mmarvalid<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Mmarvalid<Urt>

type SRegField = Mmarvalid<Srt>

type CRegField = Mmarvalid<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Mstkerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Mstkerr<Urt>

type SRegField = Mstkerr<Srt>

type CRegField = Mstkerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Munstkerr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Munstkerr<Urt>

type SRegField = Munstkerr<Srt>

type CRegField = Munstkerr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Seveonpend<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Seveonpend<Urt>

type SRegField = Seveonpend<Srt>

type CRegField = Seveonpend<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Sleepdeep<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Sleepdeep<Urt>

type SRegField = Sleepdeep<Srt>

type CRegField = Sleepdeep<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Sleeponexit<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Sleeponexit<Urt>

type SRegField = Sleeponexit<Srt>

type CRegField = Sleeponexit<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Busfaultact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Busfaultact<Urt>

type SRegField = Busfaultact<Srt>

type CRegField = Busfaultact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Busfaultena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Busfaultena<Urt>

type SRegField = Busfaultena<Srt>

type CRegField = Busfaultena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Busfaultpended<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Busfaultpended<Urt>

type SRegField = Busfaultpended<Srt>

type CRegField = Busfaultpended<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Memfaultact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Memfaultact<Urt>

type SRegField = Memfaultact<Srt>

type CRegField = Memfaultact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Memfaultena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Memfaultena<Urt>

type SRegField = Memfaultena<Srt>

type CRegField = Memfaultena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Memfaultpended<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Memfaultpended<Urt>

type SRegField = Memfaultpended<Srt>

type CRegField = Memfaultpended<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Monitoract<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Monitoract<Urt>

type SRegField = Monitoract<Srt>

type CRegField = Monitoract<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Pendsvact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Pendsvact<Urt>

type SRegField = Pendsvact<Srt>

type CRegField = Pendsvact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Svcallact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Svcallact<Urt>

type SRegField = Svcallact<Srt>

type CRegField = Svcallact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Svcallpended<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Svcallpended<Urt>

type SRegField = Svcallpended<Srt>

type CRegField = Svcallpended<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Systickact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Systickact<Urt>

type SRegField = Systickact<Srt>

type CRegField = Systickact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Usgfaultact<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Usgfaultact<Urt>

type SRegField = Usgfaultact<Srt>

type CRegField = Usgfaultact<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Usgfaultena<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Usgfaultena<Urt>

type SRegField = Usgfaultena<Srt>

type CRegField = Usgfaultena<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Usgfaultpended<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Usgfaultpended<Urt>

type SRegField = Usgfaultpended<Srt>

type CRegField = Usgfaultpended<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriBusFault<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriBusFault<Urt>

type SRegField = PriBusFault<Srt>

type CRegField = PriBusFault<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriMemManage<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriMemManage<Urt>

type SRegField = PriMemManage<Srt>

type CRegField = PriMemManage<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriUsageFault<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriUsageFault<Urt>

type SRegField = PriUsageFault<Srt>

type CRegField = PriUsageFault<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriSvCall<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriSvCall<Urt>

type SRegField = PriSvCall<Srt>

type CRegField = PriSvCall<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriPendSv<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriPendSv<Urt>

type SRegField = PriPendSv<Srt>

type CRegField = PriPendSv<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for PriSysTick<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = PriSysTick<Urt>

type SRegField = PriSysTick<Srt>

type CRegField = PriSysTick<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Divbyzero<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Divbyzero<Urt>

type SRegField = Divbyzero<Srt>

type CRegField = Divbyzero<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Invpc<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Invpc<Urt>

type SRegField = Invpc<Srt>

type CRegField = Invpc<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Invstate<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Invstate<Urt>

type SRegField = Invstate<Srt>

type CRegField = Invstate<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Nocp<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Nocp<Urt>

type SRegField = Nocp<Srt>

type CRegField = Nocp<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Unaligned<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Unaligned<Urt>

type SRegField = Unaligned<Srt>

type CRegField = Unaligned<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Undefinstr<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Undefinstr<Urt>

type SRegField = Undefinstr<Srt>

type CRegField = Undefinstr<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Tbloff<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Tbloff<Urt>

type SRegField = Tbloff<Srt>

type CRegField = Tbloff<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Noref<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Noref<Urt>

type SRegField = Noref<Srt>

type CRegField = Noref<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Skew<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Skew<Urt>

type SRegField = Skew<Srt>

type CRegField = Skew<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Tenms<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Tenms<Urt>

type SRegField = Tenms<Srt>

type CRegField = Tenms<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Clksource<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Clksource<Urt>

type SRegField = Clksource<Srt>

type CRegField = Clksource<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Countflag<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Countflag<Urt>

type SRegField = Countflag<Srt>

type CRegField = Countflag<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Enable<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Enable<Urt>

type SRegField = Enable<Srt>

type CRegField = Enable<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Tickint<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Tickint<Urt>

type SRegField = Tickint<Srt>

type CRegField = Tickint<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Reload<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Reload<Urt>

type SRegField = Reload<Srt>

type CRegField = Reload<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Current<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Current<Urt>

type SRegField = Current<Srt>

type CRegField = Current<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Swoscaler<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Swoscaler<Urt>

type SRegField = Swoscaler<Srt>

type CRegField = Swoscaler<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for EnFCont<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = EnFCont<Urt>

type SRegField = EnFCont<Srt>

type CRegField = EnFCont<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for TrigIn<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = TrigIn<Urt>

type SRegField = TrigIn<Srt>

type CRegField = TrigIn<Crt>

const OFFSET: usize

const WIDTH: usize

impl<_T> RegField<_T> for Txmode<_T> where
    _T: RegTag, 

type Reg = Reg<_T>

type URegField = Txmode<Urt>

type SRegField = Txmode<Srt>

type CRegField = Txmode<Crt>

const OFFSET: usize

const WIDTH: usize

Loading content...