4666 lines
162 KiB
Rust
4666 lines
162 KiB
Rust
//! Register definitions for Synopsys DesignWare USB OTG core
|
|
|
|
#![allow(missing_docs)]
|
|
|
|
use core::marker::PhantomData;
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
|
pub struct RW;
|
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
|
pub struct R;
|
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
|
pub struct W;
|
|
|
|
mod sealed {
|
|
use super::*;
|
|
pub trait Access {}
|
|
impl Access for R {}
|
|
impl Access for W {}
|
|
impl Access for RW {}
|
|
}
|
|
|
|
pub trait Access: sealed::Access + Copy {}
|
|
impl Access for R {}
|
|
impl Access for W {}
|
|
impl Access for RW {}
|
|
|
|
pub trait Read: Access {}
|
|
impl Read for RW {}
|
|
impl Read for R {}
|
|
|
|
pub trait Write: Access {}
|
|
impl Write for RW {}
|
|
impl Write for W {}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
|
pub struct Reg<T: Copy, A: Access> {
|
|
ptr: *mut u8,
|
|
phantom: PhantomData<*mut (T, A)>,
|
|
}
|
|
unsafe impl<T: Copy, A: Access> Send for Reg<T, A> {}
|
|
unsafe impl<T: Copy, A: Access> Sync for Reg<T, A> {}
|
|
|
|
impl<T: Copy, A: Access> Reg<T, A> {
|
|
#[allow(clippy::missing_safety_doc)]
|
|
#[inline(always)]
|
|
pub const unsafe fn from_ptr(ptr: *mut T) -> Self {
|
|
Self {
|
|
ptr: ptr as _,
|
|
phantom: PhantomData,
|
|
}
|
|
}
|
|
|
|
#[inline(always)]
|
|
pub const fn as_ptr(&self) -> *mut T {
|
|
self.ptr as _
|
|
}
|
|
}
|
|
|
|
impl<T: Copy, A: Read> Reg<T, A> {
|
|
#[inline(always)]
|
|
pub fn read(&self) -> T {
|
|
unsafe { (self.ptr as *mut T).read_volatile() }
|
|
}
|
|
}
|
|
|
|
impl<T: Copy, A: Write> Reg<T, A> {
|
|
#[inline(always)]
|
|
pub fn write_value(&self, val: T) {
|
|
unsafe { (self.ptr as *mut T).write_volatile(val) }
|
|
}
|
|
}
|
|
|
|
impl<T: Default + Copy, A: Write> Reg<T, A> {
|
|
#[inline(always)]
|
|
pub fn write<R>(&self, f: impl FnOnce(&mut T) -> R) -> R {
|
|
let mut val = Default::default();
|
|
let res = f(&mut val);
|
|
self.write_value(val);
|
|
res
|
|
}
|
|
}
|
|
|
|
impl<T: Copy, A: Read + Write> Reg<T, A> {
|
|
#[inline(always)]
|
|
pub fn modify<R>(&self, f: impl FnOnce(&mut T) -> R) -> R {
|
|
let mut val = self.read();
|
|
let res = f(&mut val);
|
|
self.write_value(val);
|
|
res
|
|
}
|
|
}
|
|
|
|
#[doc = "USB on the go"]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Otg {
|
|
ptr: *mut u8,
|
|
}
|
|
unsafe impl Send for Otg {}
|
|
unsafe impl Sync for Otg {}
|
|
impl Otg {
|
|
#[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 = "Control and status register"]
|
|
#[inline(always)]
|
|
pub fn gotgctl(self) -> Reg<regs::Gotgctl, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0usize) as _) }
|
|
}
|
|
#[doc = "Interrupt register"]
|
|
#[inline(always)]
|
|
pub fn gotgint(self) -> Reg<regs::Gotgint, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x04usize) as _) }
|
|
}
|
|
#[doc = "AHB configuration register"]
|
|
#[inline(always)]
|
|
pub fn gahbcfg(self) -> Reg<regs::Gahbcfg, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x08usize) as _) }
|
|
}
|
|
#[doc = "USB configuration register"]
|
|
#[inline(always)]
|
|
pub fn gusbcfg(self) -> Reg<regs::Gusbcfg, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
|
|
}
|
|
#[doc = "Reset register"]
|
|
#[inline(always)]
|
|
pub fn grstctl(self) -> Reg<regs::Grstctl, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x10usize) as _) }
|
|
}
|
|
#[doc = "Core interrupt register"]
|
|
#[inline(always)]
|
|
pub fn gintsts(self) -> Reg<regs::Gintsts, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x14usize) as _) }
|
|
}
|
|
#[doc = "Interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn gintmsk(self) -> Reg<regs::Gintmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x18usize) as _) }
|
|
}
|
|
#[doc = "Receive status debug read register"]
|
|
#[inline(always)]
|
|
pub fn grxstsr(self) -> Reg<regs::Grxsts, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x1cusize) as _) }
|
|
}
|
|
#[doc = "Status read and pop register"]
|
|
#[inline(always)]
|
|
pub fn grxstsp(self) -> Reg<regs::Grxsts, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x20usize) as _) }
|
|
}
|
|
#[doc = "Receive FIFO size register"]
|
|
#[inline(always)]
|
|
pub fn grxfsiz(self) -> Reg<regs::Grxfsiz, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x24usize) as _) }
|
|
}
|
|
#[doc = "Endpoint 0 transmit FIFO size register (device mode)"]
|
|
#[inline(always)]
|
|
pub fn dieptxf0(self) -> Reg<regs::Fsiz, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x28usize) as _) }
|
|
}
|
|
#[doc = "Non-periodic transmit FIFO size register (host mode)"]
|
|
#[inline(always)]
|
|
pub fn hnptxfsiz(self) -> Reg<regs::Fsiz, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x28usize) as _) }
|
|
}
|
|
#[doc = "Non-periodic transmit FIFO/queue status register (host mode)"]
|
|
#[inline(always)]
|
|
pub fn hnptxsts(self) -> Reg<regs::Hnptxsts, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x2cusize) as _) }
|
|
}
|
|
#[doc = "OTG I2C access register"]
|
|
#[inline(always)]
|
|
pub fn gi2cctl(self) -> Reg<regs::Gi2cctl, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x30usize) as _) }
|
|
}
|
|
#[doc = "General core configuration register, for core_id 0x0000_1xxx"]
|
|
#[inline(always)]
|
|
pub fn gccfg_v1(self) -> Reg<regs::GccfgV1, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x38usize) as _) }
|
|
}
|
|
#[doc = "General core configuration register, for core_id 0x0000_\\[23\\]xxx"]
|
|
#[inline(always)]
|
|
pub fn gccfg_v2(self) -> Reg<regs::GccfgV2, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x38usize) as _) }
|
|
}
|
|
#[doc = "General core configuration register, for core_id 0x0000_5xxx"]
|
|
#[inline(always)]
|
|
pub fn gccfg_v3(self) -> Reg<regs::GccfgV3, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x38usize) as _) }
|
|
}
|
|
#[doc = "Core ID register"]
|
|
#[inline(always)]
|
|
pub fn cid(self) -> Reg<regs::Cid, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x3cusize) as _) }
|
|
}
|
|
#[doc = "OTG core LPM configuration register"]
|
|
#[inline(always)]
|
|
pub fn glpmcfg(self) -> Reg<regs::Glpmcfg, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x54usize) as _) }
|
|
}
|
|
#[doc = "Host periodic transmit FIFO size register"]
|
|
#[inline(always)]
|
|
pub fn hptxfsiz(self) -> Reg<regs::Fsiz, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0100usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint transmit FIFO size register"]
|
|
#[inline(always)]
|
|
pub fn dieptxf(self, n: usize) -> Reg<regs::Fsiz, RW> {
|
|
assert!(n < 7usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0104usize + n * 4usize) as _) }
|
|
}
|
|
#[doc = "Host configuration register"]
|
|
#[inline(always)]
|
|
pub fn hcfg(self) -> Reg<regs::Hcfg, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0400usize) as _) }
|
|
}
|
|
#[doc = "Host frame interval register"]
|
|
#[inline(always)]
|
|
pub fn hfir(self) -> Reg<regs::Hfir, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0404usize) as _) }
|
|
}
|
|
#[doc = "Host frame number/frame time remaining register"]
|
|
#[inline(always)]
|
|
pub fn hfnum(self) -> Reg<regs::Hfnum, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0408usize) as _) }
|
|
}
|
|
#[doc = "Periodic transmit FIFO/queue status register"]
|
|
#[inline(always)]
|
|
pub fn hptxsts(self) -> Reg<regs::Hptxsts, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0410usize) as _) }
|
|
}
|
|
#[doc = "Host all channels interrupt register"]
|
|
#[inline(always)]
|
|
pub fn haint(self) -> Reg<regs::Haint, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0414usize) as _) }
|
|
}
|
|
#[doc = "Host all channels interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn haintmsk(self) -> Reg<regs::Haintmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0418usize) as _) }
|
|
}
|
|
#[doc = "Host port control and status register"]
|
|
#[inline(always)]
|
|
pub fn hprt(self) -> Reg<regs::Hprt, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0440usize) as _) }
|
|
}
|
|
#[doc = "Host channel characteristics register"]
|
|
#[inline(always)]
|
|
pub fn hcchar(self, n: usize) -> Reg<regs::Hcchar, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0500usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Host channel split control register"]
|
|
#[inline(always)]
|
|
pub fn hcsplt(self, n: usize) -> Reg<u32, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0504usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Host channel interrupt register"]
|
|
#[inline(always)]
|
|
pub fn hcint(self, n: usize) -> Reg<regs::Hcint, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0508usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Host channel mask register"]
|
|
#[inline(always)]
|
|
pub fn hcintmsk(self, n: usize) -> Reg<regs::Hcintmsk, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x050cusize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Host channel transfer size register"]
|
|
#[inline(always)]
|
|
pub fn hctsiz(self, n: usize) -> Reg<regs::Hctsiz, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0510usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Host channel DMA address register"]
|
|
#[inline(always)]
|
|
pub fn hcdma(self, n: usize) -> Reg<u32, RW> {
|
|
assert!(n < 12usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0514usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device configuration register"]
|
|
#[inline(always)]
|
|
pub fn dcfg(self) -> Reg<regs::Dcfg, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0800usize) as _) }
|
|
}
|
|
#[doc = "Device control register"]
|
|
#[inline(always)]
|
|
pub fn dctl(self) -> Reg<regs::Dctl, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0804usize) as _) }
|
|
}
|
|
#[doc = "Device status register"]
|
|
#[inline(always)]
|
|
pub fn dsts(self) -> Reg<regs::Dsts, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0808usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint common interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn diepmsk(self) -> Reg<regs::Diepmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0810usize) as _) }
|
|
}
|
|
#[doc = "Device OUT endpoint common interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn doepmsk(self) -> Reg<regs::Doepmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0814usize) as _) }
|
|
}
|
|
#[doc = "Device all endpoints interrupt register"]
|
|
#[inline(always)]
|
|
pub fn daint(self) -> Reg<regs::Daint, R> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0818usize) as _) }
|
|
}
|
|
#[doc = "All endpoints interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn daintmsk(self) -> Reg<regs::Daintmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x081cusize) as _) }
|
|
}
|
|
#[doc = "Device VBUS discharge time register"]
|
|
#[inline(always)]
|
|
pub fn dvbusdis(self) -> Reg<regs::Dvbusdis, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0828usize) as _) }
|
|
}
|
|
#[doc = "Device VBUS pulsing time register"]
|
|
#[inline(always)]
|
|
pub fn dvbuspulse(self) -> Reg<regs::Dvbuspulse, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x082cusize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint FIFO empty interrupt mask register"]
|
|
#[inline(always)]
|
|
pub fn diepempmsk(self) -> Reg<regs::Diepempmsk, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0834usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint control register"]
|
|
#[inline(always)]
|
|
pub fn diepctl(self, n: usize) -> Reg<regs::Diepctl, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0900usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint interrupt register"]
|
|
#[inline(always)]
|
|
pub fn diepint(self, n: usize) -> Reg<regs::Diepint, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0908usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint transfer size register"]
|
|
#[inline(always)]
|
|
pub fn dieptsiz(self, n: usize) -> Reg<regs::Dieptsiz, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0910usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device IN endpoint transmit FIFO status register"]
|
|
#[inline(always)]
|
|
pub fn dtxfsts(self, n: usize) -> Reg<regs::Dtxfsts, R> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0918usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device OUT endpoint control register"]
|
|
#[inline(always)]
|
|
pub fn doepctl(self, n: usize) -> Reg<regs::Doepctl, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0b00usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device OUT endpoint interrupt register"]
|
|
#[inline(always)]
|
|
pub fn doepint(self, n: usize) -> Reg<regs::Doepint, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0b08usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device OUT endpoint transfer size register"]
|
|
#[inline(always)]
|
|
pub fn doeptsiz(self, n: usize) -> Reg<regs::Doeptsiz, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0b10usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Device OUT/IN endpoint DMA address register"]
|
|
#[inline(always)]
|
|
pub fn doepdma(self, n: usize) -> Reg<u32, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0b14usize + n * 32usize) as _) }
|
|
}
|
|
#[doc = "Power and clock gating control register"]
|
|
#[inline(always)]
|
|
pub fn pcgcctl(self) -> Reg<regs::Pcgcctl, RW> {
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x0e00usize) as _) }
|
|
}
|
|
#[doc = "Device endpoint / host channel FIFO register"]
|
|
#[inline(always)]
|
|
pub fn fifo(self, n: usize) -> Reg<regs::Fifo, RW> {
|
|
assert!(n < 16usize);
|
|
unsafe { Reg::from_ptr(self.ptr.add(0x1000usize + n * 4096usize) as _) }
|
|
}
|
|
}
|
|
pub mod regs {
|
|
#[doc = "Core ID register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Cid(pub u32);
|
|
impl Cid {
|
|
#[doc = "Product ID field"]
|
|
#[inline(always)]
|
|
pub const fn product_id(&self) -> u32 {
|
|
let val = (self.0 >> 0usize) & 0xffff_ffff;
|
|
val as u32
|
|
}
|
|
#[doc = "Product ID field"]
|
|
#[inline(always)]
|
|
pub fn set_product_id(&mut self, val: u32) {
|
|
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Cid {
|
|
#[inline(always)]
|
|
fn default() -> Cid {
|
|
Cid(0)
|
|
}
|
|
}
|
|
#[doc = "Device all endpoints interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Daint(pub u32);
|
|
impl Daint {
|
|
#[doc = "IN endpoint interrupt bits"]
|
|
#[inline(always)]
|
|
pub const fn iepint(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "IN endpoint interrupt bits"]
|
|
#[inline(always)]
|
|
pub fn set_iepint(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "OUT endpoint interrupt bits"]
|
|
#[inline(always)]
|
|
pub const fn oepint(&self) -> u16 {
|
|
let val = (self.0 >> 16usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "OUT endpoint interrupt bits"]
|
|
#[inline(always)]
|
|
pub fn set_oepint(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
|
|
}
|
|
}
|
|
impl Default for Daint {
|
|
#[inline(always)]
|
|
fn default() -> Daint {
|
|
Daint(0)
|
|
}
|
|
}
|
|
#[doc = "All endpoints interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Daintmsk(pub u32);
|
|
impl Daintmsk {
|
|
#[doc = "IN EP interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub const fn iepm(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "IN EP interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub fn set_iepm(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "OUT EP interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub const fn oepm(&self) -> u16 {
|
|
let val = (self.0 >> 16usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "OUT EP interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub fn set_oepm(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
|
|
}
|
|
}
|
|
impl Default for Daintmsk {
|
|
#[inline(always)]
|
|
fn default() -> Daintmsk {
|
|
Daintmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Device configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dcfg(pub u32);
|
|
impl Dcfg {
|
|
#[doc = "Device speed"]
|
|
#[inline(always)]
|
|
pub const fn dspd(&self) -> super::vals::Dspd {
|
|
let val = (self.0 >> 0usize) & 0x03;
|
|
super::vals::Dspd::from_bits(val as u8)
|
|
}
|
|
#[doc = "Device speed"]
|
|
#[inline(always)]
|
|
pub fn set_dspd(&mut self, val: super::vals::Dspd) {
|
|
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
|
|
}
|
|
#[doc = "Non-zero-length status OUT handshake"]
|
|
#[inline(always)]
|
|
pub const fn nzlsohsk(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Non-zero-length status OUT handshake"]
|
|
#[inline(always)]
|
|
pub fn set_nzlsohsk(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Device address"]
|
|
#[inline(always)]
|
|
pub const fn dad(&self) -> u8 {
|
|
let val = (self.0 >> 4usize) & 0x7f;
|
|
val as u8
|
|
}
|
|
#[doc = "Device address"]
|
|
#[inline(always)]
|
|
pub fn set_dad(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x7f << 4usize)) | (((val as u32) & 0x7f) << 4usize);
|
|
}
|
|
#[doc = "Periodic frame interval"]
|
|
#[inline(always)]
|
|
pub const fn pfivl(&self) -> super::vals::Pfivl {
|
|
let val = (self.0 >> 11usize) & 0x03;
|
|
super::vals::Pfivl::from_bits(val as u8)
|
|
}
|
|
#[doc = "Periodic frame interval"]
|
|
#[inline(always)]
|
|
pub fn set_pfivl(&mut self, val: super::vals::Pfivl) {
|
|
self.0 = (self.0 & !(0x03 << 11usize)) | (((val.to_bits() as u32) & 0x03) << 11usize);
|
|
}
|
|
#[doc = "Transceiver delay"]
|
|
#[inline(always)]
|
|
pub const fn xcvrdly(&self) -> bool {
|
|
let val = (self.0 >> 14usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transceiver delay"]
|
|
#[inline(always)]
|
|
pub fn set_xcvrdly(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
|
|
}
|
|
}
|
|
impl Default for Dcfg {
|
|
#[inline(always)]
|
|
fn default() -> Dcfg {
|
|
Dcfg(0)
|
|
}
|
|
}
|
|
#[doc = "Device control register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dctl(pub u32);
|
|
impl Dctl {
|
|
#[doc = "Remote wakeup signaling"]
|
|
#[inline(always)]
|
|
pub const fn rwusig(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Remote wakeup signaling"]
|
|
#[inline(always)]
|
|
pub fn set_rwusig(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Soft disconnect"]
|
|
#[inline(always)]
|
|
pub const fn sdis(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Soft disconnect"]
|
|
#[inline(always)]
|
|
pub fn set_sdis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Global IN NAK status"]
|
|
#[inline(always)]
|
|
pub const fn ginsts(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global IN NAK status"]
|
|
#[inline(always)]
|
|
pub fn set_ginsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Global OUT NAK status"]
|
|
#[inline(always)]
|
|
pub const fn gonsts(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global OUT NAK status"]
|
|
#[inline(always)]
|
|
pub fn set_gonsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Test control"]
|
|
#[inline(always)]
|
|
pub const fn tctl(&self) -> u8 {
|
|
let val = (self.0 >> 4usize) & 0x07;
|
|
val as u8
|
|
}
|
|
#[doc = "Test control"]
|
|
#[inline(always)]
|
|
pub fn set_tctl(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
|
|
}
|
|
#[doc = "Set global IN NAK"]
|
|
#[inline(always)]
|
|
pub const fn sginak(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Set global IN NAK"]
|
|
#[inline(always)]
|
|
pub fn set_sginak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Clear global IN NAK"]
|
|
#[inline(always)]
|
|
pub const fn cginak(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Clear global IN NAK"]
|
|
#[inline(always)]
|
|
pub fn set_cginak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "Set global OUT NAK"]
|
|
#[inline(always)]
|
|
pub const fn sgonak(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Set global OUT NAK"]
|
|
#[inline(always)]
|
|
pub fn set_sgonak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "Clear global OUT NAK"]
|
|
#[inline(always)]
|
|
pub const fn cgonak(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Clear global OUT NAK"]
|
|
#[inline(always)]
|
|
pub fn set_cgonak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
#[doc = "Power-on programming done"]
|
|
#[inline(always)]
|
|
pub const fn poprgdne(&self) -> bool {
|
|
let val = (self.0 >> 11usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Power-on programming done"]
|
|
#[inline(always)]
|
|
pub fn set_poprgdne(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
|
|
}
|
|
}
|
|
impl Default for Dctl {
|
|
#[inline(always)]
|
|
fn default() -> Dctl {
|
|
Dctl(0)
|
|
}
|
|
}
|
|
#[doc = "Device endpoint control register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Diepctl(pub u32);
|
|
impl Diepctl {
|
|
#[doc = "MPSIZ"]
|
|
#[inline(always)]
|
|
pub const fn mpsiz(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0x07ff;
|
|
val as u16
|
|
}
|
|
#[doc = "MPSIZ"]
|
|
#[inline(always)]
|
|
pub fn set_mpsiz(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x07ff << 0usize)) | (((val as u32) & 0x07ff) << 0usize);
|
|
}
|
|
#[doc = "USBAEP"]
|
|
#[inline(always)]
|
|
pub const fn usbaep(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USBAEP"]
|
|
#[inline(always)]
|
|
pub fn set_usbaep(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "EONUM/DPID"]
|
|
#[inline(always)]
|
|
pub const fn eonum_dpid(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EONUM/DPID"]
|
|
#[inline(always)]
|
|
pub fn set_eonum_dpid(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "NAKSTS"]
|
|
#[inline(always)]
|
|
pub const fn naksts(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "NAKSTS"]
|
|
#[inline(always)]
|
|
pub fn set_naksts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "EPTYP"]
|
|
#[inline(always)]
|
|
pub const fn eptyp(&self) -> super::vals::Eptyp {
|
|
let val = (self.0 >> 18usize) & 0x03;
|
|
super::vals::Eptyp::from_bits(val as u8)
|
|
}
|
|
#[doc = "EPTYP"]
|
|
#[inline(always)]
|
|
pub fn set_eptyp(&mut self, val: super::vals::Eptyp) {
|
|
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
|
|
}
|
|
#[doc = "SNPM"]
|
|
#[inline(always)]
|
|
pub const fn snpm(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SNPM"]
|
|
#[inline(always)]
|
|
pub fn set_snpm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "STALL"]
|
|
#[inline(always)]
|
|
pub const fn stall(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "STALL"]
|
|
#[inline(always)]
|
|
pub fn set_stall(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "TXFNUM"]
|
|
#[inline(always)]
|
|
pub const fn txfnum(&self) -> u8 {
|
|
let val = (self.0 >> 22usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "TXFNUM"]
|
|
#[inline(always)]
|
|
pub fn set_txfnum(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 22usize)) | (((val as u32) & 0x0f) << 22usize);
|
|
}
|
|
#[doc = "CNAK"]
|
|
#[inline(always)]
|
|
pub const fn cnak(&self) -> bool {
|
|
let val = (self.0 >> 26usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "CNAK"]
|
|
#[inline(always)]
|
|
pub fn set_cnak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
|
|
}
|
|
#[doc = "SNAK"]
|
|
#[inline(always)]
|
|
pub const fn snak(&self) -> bool {
|
|
let val = (self.0 >> 27usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SNAK"]
|
|
#[inline(always)]
|
|
pub fn set_snak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
|
|
}
|
|
#[doc = "SD0PID/SEVNFRM"]
|
|
#[inline(always)]
|
|
pub const fn sd0pid_sevnfrm(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SD0PID/SEVNFRM"]
|
|
#[inline(always)]
|
|
pub fn set_sd0pid_sevnfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
#[doc = "SD1PID/SODDFRM"]
|
|
#[inline(always)]
|
|
pub const fn sd1pid_soddfrm(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SD1PID/SODDFRM"]
|
|
#[inline(always)]
|
|
pub fn set_sd1pid_soddfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "EPDIS"]
|
|
#[inline(always)]
|
|
pub const fn epdis(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPDIS"]
|
|
#[inline(always)]
|
|
pub fn set_epdis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "EPENA"]
|
|
#[inline(always)]
|
|
pub const fn epena(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPENA"]
|
|
#[inline(always)]
|
|
pub fn set_epena(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Diepctl {
|
|
#[inline(always)]
|
|
fn default() -> Diepctl {
|
|
Diepctl(0)
|
|
}
|
|
}
|
|
#[doc = "Device IN endpoint FIFO empty interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Diepempmsk(pub u32);
|
|
impl Diepempmsk {
|
|
#[doc = "IN EP Tx FIFO empty interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub const fn ineptxfem(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "IN EP Tx FIFO empty interrupt mask bits"]
|
|
#[inline(always)]
|
|
pub fn set_ineptxfem(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Diepempmsk {
|
|
#[inline(always)]
|
|
fn default() -> Diepempmsk {
|
|
Diepempmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Device endpoint interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Diepint(pub u32);
|
|
impl Diepint {
|
|
#[doc = "XFRC"]
|
|
#[inline(always)]
|
|
pub const fn xfrc(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "XFRC"]
|
|
#[inline(always)]
|
|
pub fn set_xfrc(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "EPDISD"]
|
|
#[inline(always)]
|
|
pub const fn epdisd(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPDISD"]
|
|
#[inline(always)]
|
|
pub fn set_epdisd(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "TOC"]
|
|
#[inline(always)]
|
|
pub const fn toc(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "TOC"]
|
|
#[inline(always)]
|
|
pub fn set_toc(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "ITTXFE"]
|
|
#[inline(always)]
|
|
pub const fn ittxfe(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ITTXFE"]
|
|
#[inline(always)]
|
|
pub fn set_ittxfe(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "INEPNE"]
|
|
#[inline(always)]
|
|
pub const fn inepne(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "INEPNE"]
|
|
#[inline(always)]
|
|
pub fn set_inepne(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "TXFE"]
|
|
#[inline(always)]
|
|
pub const fn txfe(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "TXFE"]
|
|
#[inline(always)]
|
|
pub fn set_txfe(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
}
|
|
impl Default for Diepint {
|
|
#[inline(always)]
|
|
fn default() -> Diepint {
|
|
Diepint(0)
|
|
}
|
|
}
|
|
#[doc = "Device IN endpoint common interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Diepmsk(pub u32);
|
|
impl Diepmsk {
|
|
#[doc = "Transfer completed interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn xfrcm(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transfer completed interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_xfrcm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Endpoint disabled interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn epdm(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Endpoint disabled interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_epdm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Timeout condition mask (Non-isochronous endpoints)"]
|
|
#[inline(always)]
|
|
pub const fn tom(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Timeout condition mask (Non-isochronous endpoints)"]
|
|
#[inline(always)]
|
|
pub fn set_tom(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "IN token received when TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub const fn ittxfemsk(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "IN token received when TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub fn set_ittxfemsk(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "IN token received with EP mismatch mask"]
|
|
#[inline(always)]
|
|
pub const fn inepnmm(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "IN token received with EP mismatch mask"]
|
|
#[inline(always)]
|
|
pub fn set_inepnmm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "IN endpoint NAK effective mask"]
|
|
#[inline(always)]
|
|
pub const fn inepnem(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "IN endpoint NAK effective mask"]
|
|
#[inline(always)]
|
|
pub fn set_inepnem(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
}
|
|
impl Default for Diepmsk {
|
|
#[inline(always)]
|
|
fn default() -> Diepmsk {
|
|
Diepmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Device endpoint transfer size register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dieptsiz(pub u32);
|
|
impl Dieptsiz {
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub const fn xfrsiz(&self) -> u32 {
|
|
let val = (self.0 >> 0usize) & 0x0007_ffff;
|
|
val as u32
|
|
}
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub fn set_xfrsiz(&mut self, val: u32) {
|
|
self.0 = (self.0 & !(0x0007_ffff << 0usize)) | (((val as u32) & 0x0007_ffff) << 0usize);
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub const fn pktcnt(&self) -> u16 {
|
|
let val = (self.0 >> 19usize) & 0x03ff;
|
|
val as u16
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub fn set_pktcnt(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x03ff << 19usize)) | (((val as u32) & 0x03ff) << 19usize);
|
|
}
|
|
#[doc = "Multi count"]
|
|
#[inline(always)]
|
|
pub const fn mcnt(&self) -> u8 {
|
|
let val = (self.0 >> 29usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Multi count"]
|
|
#[inline(always)]
|
|
pub fn set_mcnt(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 29usize)) | (((val as u32) & 0x03) << 29usize);
|
|
}
|
|
}
|
|
impl Default for Dieptsiz {
|
|
#[inline(always)]
|
|
fn default() -> Dieptsiz {
|
|
Dieptsiz(0)
|
|
}
|
|
}
|
|
#[doc = "Device endpoint control register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Doepctl(pub u32);
|
|
impl Doepctl {
|
|
#[doc = "MPSIZ"]
|
|
#[inline(always)]
|
|
pub const fn mpsiz(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0x07ff;
|
|
val as u16
|
|
}
|
|
#[doc = "MPSIZ"]
|
|
#[inline(always)]
|
|
pub fn set_mpsiz(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x07ff << 0usize)) | (((val as u32) & 0x07ff) << 0usize);
|
|
}
|
|
#[doc = "USBAEP"]
|
|
#[inline(always)]
|
|
pub const fn usbaep(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USBAEP"]
|
|
#[inline(always)]
|
|
pub fn set_usbaep(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "EONUM/DPID"]
|
|
#[inline(always)]
|
|
pub const fn eonum_dpid(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EONUM/DPID"]
|
|
#[inline(always)]
|
|
pub fn set_eonum_dpid(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "NAKSTS"]
|
|
#[inline(always)]
|
|
pub const fn naksts(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "NAKSTS"]
|
|
#[inline(always)]
|
|
pub fn set_naksts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "EPTYP"]
|
|
#[inline(always)]
|
|
pub const fn eptyp(&self) -> super::vals::Eptyp {
|
|
let val = (self.0 >> 18usize) & 0x03;
|
|
super::vals::Eptyp::from_bits(val as u8)
|
|
}
|
|
#[doc = "EPTYP"]
|
|
#[inline(always)]
|
|
pub fn set_eptyp(&mut self, val: super::vals::Eptyp) {
|
|
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
|
|
}
|
|
#[doc = "SNPM"]
|
|
#[inline(always)]
|
|
pub const fn snpm(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SNPM"]
|
|
#[inline(always)]
|
|
pub fn set_snpm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "STALL"]
|
|
#[inline(always)]
|
|
pub const fn stall(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "STALL"]
|
|
#[inline(always)]
|
|
pub fn set_stall(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "CNAK"]
|
|
#[inline(always)]
|
|
pub const fn cnak(&self) -> bool {
|
|
let val = (self.0 >> 26usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "CNAK"]
|
|
#[inline(always)]
|
|
pub fn set_cnak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
|
|
}
|
|
#[doc = "SNAK"]
|
|
#[inline(always)]
|
|
pub const fn snak(&self) -> bool {
|
|
let val = (self.0 >> 27usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SNAK"]
|
|
#[inline(always)]
|
|
pub fn set_snak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
|
|
}
|
|
#[doc = "SD0PID/SEVNFRM"]
|
|
#[inline(always)]
|
|
pub const fn sd0pid_sevnfrm(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SD0PID/SEVNFRM"]
|
|
#[inline(always)]
|
|
pub fn set_sd0pid_sevnfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
#[doc = "SD1PID/SODDFRM"]
|
|
#[inline(always)]
|
|
pub const fn sd1pid_soddfrm(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SD1PID/SODDFRM"]
|
|
#[inline(always)]
|
|
pub fn set_sd1pid_soddfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "EPDIS"]
|
|
#[inline(always)]
|
|
pub const fn epdis(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPDIS"]
|
|
#[inline(always)]
|
|
pub fn set_epdis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "EPENA"]
|
|
#[inline(always)]
|
|
pub const fn epena(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPENA"]
|
|
#[inline(always)]
|
|
pub fn set_epena(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Doepctl {
|
|
#[inline(always)]
|
|
fn default() -> Doepctl {
|
|
Doepctl(0)
|
|
}
|
|
}
|
|
#[doc = "Device endpoint interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Doepint(pub u32);
|
|
impl Doepint {
|
|
#[doc = "XFRC"]
|
|
#[inline(always)]
|
|
pub const fn xfrc(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "XFRC"]
|
|
#[inline(always)]
|
|
pub fn set_xfrc(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "EPDISD"]
|
|
#[inline(always)]
|
|
pub const fn epdisd(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "EPDISD"]
|
|
#[inline(always)]
|
|
pub fn set_epdisd(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "STUP"]
|
|
#[inline(always)]
|
|
pub const fn stup(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "STUP"]
|
|
#[inline(always)]
|
|
pub fn set_stup(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "OTEPDIS"]
|
|
#[inline(always)]
|
|
pub const fn otepdis(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OTEPDIS"]
|
|
#[inline(always)]
|
|
pub fn set_otepdis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "B2BSTUP"]
|
|
#[inline(always)]
|
|
pub const fn b2bstup(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "B2BSTUP"]
|
|
#[inline(always)]
|
|
pub fn set_b2bstup(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
}
|
|
impl Default for Doepint {
|
|
#[inline(always)]
|
|
fn default() -> Doepint {
|
|
Doepint(0)
|
|
}
|
|
}
|
|
#[doc = "Device OUT endpoint common interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Doepmsk(pub u32);
|
|
impl Doepmsk {
|
|
#[doc = "Transfer completed interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn xfrcm(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transfer completed interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_xfrcm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Endpoint disabled interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn epdm(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Endpoint disabled interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_epdm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "SETUP phase done mask"]
|
|
#[inline(always)]
|
|
pub const fn stupm(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SETUP phase done mask"]
|
|
#[inline(always)]
|
|
pub fn set_stupm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "OUT token received when endpoint disabled mask"]
|
|
#[inline(always)]
|
|
pub const fn otepdm(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OUT token received when endpoint disabled mask"]
|
|
#[inline(always)]
|
|
pub fn set_otepdm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
}
|
|
impl Default for Doepmsk {
|
|
#[inline(always)]
|
|
fn default() -> Doepmsk {
|
|
Doepmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Device OUT endpoint transfer size register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Doeptsiz(pub u32);
|
|
impl Doeptsiz {
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub const fn xfrsiz(&self) -> u32 {
|
|
let val = (self.0 >> 0usize) & 0x0007_ffff;
|
|
val as u32
|
|
}
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub fn set_xfrsiz(&mut self, val: u32) {
|
|
self.0 = (self.0 & !(0x0007_ffff << 0usize)) | (((val as u32) & 0x0007_ffff) << 0usize);
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub const fn pktcnt(&self) -> u16 {
|
|
let val = (self.0 >> 19usize) & 0x03ff;
|
|
val as u16
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub fn set_pktcnt(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x03ff << 19usize)) | (((val as u32) & 0x03ff) << 19usize);
|
|
}
|
|
#[doc = "Received data PID/SETUP packet count"]
|
|
#[inline(always)]
|
|
pub const fn rxdpid_stupcnt(&self) -> u8 {
|
|
let val = (self.0 >> 29usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Received data PID/SETUP packet count"]
|
|
#[inline(always)]
|
|
pub fn set_rxdpid_stupcnt(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 29usize)) | (((val as u32) & 0x03) << 29usize);
|
|
}
|
|
}
|
|
impl Default for Doeptsiz {
|
|
#[inline(always)]
|
|
fn default() -> Doeptsiz {
|
|
Doeptsiz(0)
|
|
}
|
|
}
|
|
#[doc = "Device status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dsts(pub u32);
|
|
impl Dsts {
|
|
#[doc = "Suspend status"]
|
|
#[inline(always)]
|
|
pub const fn suspsts(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Suspend status"]
|
|
#[inline(always)]
|
|
pub fn set_suspsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Enumerated speed"]
|
|
#[inline(always)]
|
|
pub const fn enumspd(&self) -> super::vals::Dspd {
|
|
let val = (self.0 >> 1usize) & 0x03;
|
|
super::vals::Dspd::from_bits(val as u8)
|
|
}
|
|
#[doc = "Enumerated speed"]
|
|
#[inline(always)]
|
|
pub fn set_enumspd(&mut self, val: super::vals::Dspd) {
|
|
self.0 = (self.0 & !(0x03 << 1usize)) | (((val.to_bits() as u32) & 0x03) << 1usize);
|
|
}
|
|
#[doc = "Erratic error"]
|
|
#[inline(always)]
|
|
pub const fn eerr(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Erratic error"]
|
|
#[inline(always)]
|
|
pub fn set_eerr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Frame number of the received SOF"]
|
|
#[inline(always)]
|
|
pub const fn fnsof(&self) -> u16 {
|
|
let val = (self.0 >> 8usize) & 0x3fff;
|
|
val as u16
|
|
}
|
|
#[doc = "Frame number of the received SOF"]
|
|
#[inline(always)]
|
|
pub fn set_fnsof(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x3fff << 8usize)) | (((val as u32) & 0x3fff) << 8usize);
|
|
}
|
|
}
|
|
impl Default for Dsts {
|
|
#[inline(always)]
|
|
fn default() -> Dsts {
|
|
Dsts(0)
|
|
}
|
|
}
|
|
#[doc = "Device IN endpoint transmit FIFO status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dtxfsts(pub u32);
|
|
impl Dtxfsts {
|
|
#[doc = "IN endpoint TxFIFO space available"]
|
|
#[inline(always)]
|
|
pub const fn ineptfsav(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "IN endpoint TxFIFO space available"]
|
|
#[inline(always)]
|
|
pub fn set_ineptfsav(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Dtxfsts {
|
|
#[inline(always)]
|
|
fn default() -> Dtxfsts {
|
|
Dtxfsts(0)
|
|
}
|
|
}
|
|
#[doc = "Device VBUS discharge time register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dvbusdis(pub u32);
|
|
impl Dvbusdis {
|
|
#[doc = "Device VBUS discharge time"]
|
|
#[inline(always)]
|
|
pub const fn vbusdt(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Device VBUS discharge time"]
|
|
#[inline(always)]
|
|
pub fn set_vbusdt(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Dvbusdis {
|
|
#[inline(always)]
|
|
fn default() -> Dvbusdis {
|
|
Dvbusdis(0)
|
|
}
|
|
}
|
|
#[doc = "Device VBUS pulsing time register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Dvbuspulse(pub u32);
|
|
impl Dvbuspulse {
|
|
#[doc = "Device VBUS pulsing time"]
|
|
#[inline(always)]
|
|
pub const fn dvbusp(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0x0fff;
|
|
val as u16
|
|
}
|
|
#[doc = "Device VBUS pulsing time"]
|
|
#[inline(always)]
|
|
pub fn set_dvbusp(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x0fff << 0usize)) | (((val as u32) & 0x0fff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Dvbuspulse {
|
|
#[inline(always)]
|
|
fn default() -> Dvbuspulse {
|
|
Dvbuspulse(0)
|
|
}
|
|
}
|
|
#[doc = "FIFO register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Fifo(pub u32);
|
|
impl Fifo {
|
|
#[doc = "Data"]
|
|
#[inline(always)]
|
|
pub const fn data(&self) -> u32 {
|
|
let val = (self.0 >> 0usize) & 0xffff_ffff;
|
|
val as u32
|
|
}
|
|
#[doc = "Data"]
|
|
#[inline(always)]
|
|
pub fn set_data(&mut self, val: u32) {
|
|
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Fifo {
|
|
#[inline(always)]
|
|
fn default() -> Fifo {
|
|
Fifo(0)
|
|
}
|
|
}
|
|
#[doc = "FIFO size register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Fsiz(pub u32);
|
|
impl Fsiz {
|
|
#[doc = "RAM start address"]
|
|
#[inline(always)]
|
|
pub const fn sa(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "RAM start address"]
|
|
#[inline(always)]
|
|
pub fn set_sa(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "FIFO depth"]
|
|
#[inline(always)]
|
|
pub const fn fd(&self) -> u16 {
|
|
let val = (self.0 >> 16usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "FIFO depth"]
|
|
#[inline(always)]
|
|
pub fn set_fd(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
|
|
}
|
|
}
|
|
impl Default for Fsiz {
|
|
#[inline(always)]
|
|
fn default() -> Fsiz {
|
|
Fsiz(0)
|
|
}
|
|
}
|
|
#[doc = "AHB configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gahbcfg(pub u32);
|
|
impl Gahbcfg {
|
|
#[doc = "Global interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn gint(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_gint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Burst length/type"]
|
|
#[inline(always)]
|
|
pub const fn hbstlen(&self) -> u8 {
|
|
let val = (self.0 >> 1usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Burst length/type"]
|
|
#[inline(always)]
|
|
pub fn set_hbstlen(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 1usize)) | (((val as u32) & 0x0f) << 1usize);
|
|
}
|
|
#[doc = "DMA enable"]
|
|
#[inline(always)]
|
|
pub const fn dmaen(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "DMA enable"]
|
|
#[inline(always)]
|
|
pub fn set_dmaen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "TxFIFO empty level"]
|
|
#[inline(always)]
|
|
pub const fn txfelvl(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "TxFIFO empty level"]
|
|
#[inline(always)]
|
|
pub fn set_txfelvl(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Periodic TxFIFO empty level"]
|
|
#[inline(always)]
|
|
pub const fn ptxfelvl(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Periodic TxFIFO empty level"]
|
|
#[inline(always)]
|
|
pub fn set_ptxfelvl(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
}
|
|
impl Default for Gahbcfg {
|
|
#[inline(always)]
|
|
fn default() -> Gahbcfg {
|
|
Gahbcfg(0)
|
|
}
|
|
}
|
|
#[doc = "General core configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct GccfgV1(pub u32);
|
|
impl GccfgV1 {
|
|
#[doc = "Power down"]
|
|
#[inline(always)]
|
|
pub const fn pwrdwn(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Power down"]
|
|
#[inline(always)]
|
|
pub fn set_pwrdwn(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "Enable the VBUS \"A\" sensing device"]
|
|
#[inline(always)]
|
|
pub const fn vbusasen(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enable the VBUS \"A\" sensing device"]
|
|
#[inline(always)]
|
|
pub fn set_vbusasen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "Enable the VBUS \"B\" sensing device"]
|
|
#[inline(always)]
|
|
pub const fn vbusbsen(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enable the VBUS \"B\" sensing device"]
|
|
#[inline(always)]
|
|
pub fn set_vbusbsen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "SOF output enable"]
|
|
#[inline(always)]
|
|
pub const fn sofouten(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SOF output enable"]
|
|
#[inline(always)]
|
|
pub fn set_sofouten(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "VBUS sensing disable"]
|
|
#[inline(always)]
|
|
pub const fn novbussens(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "VBUS sensing disable"]
|
|
#[inline(always)]
|
|
pub fn set_novbussens(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
}
|
|
impl Default for GccfgV1 {
|
|
#[inline(always)]
|
|
fn default() -> GccfgV1 {
|
|
GccfgV1(0)
|
|
}
|
|
}
|
|
#[doc = "General core configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct GccfgV2(pub u32);
|
|
impl GccfgV2 {
|
|
#[doc = "Data contact detection (DCD) status"]
|
|
#[inline(always)]
|
|
pub const fn dcdet(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data contact detection (DCD) status"]
|
|
#[inline(always)]
|
|
pub fn set_dcdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Primary detection (PD) status"]
|
|
#[inline(always)]
|
|
pub const fn pdet(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Primary detection (PD) status"]
|
|
#[inline(always)]
|
|
pub fn set_pdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Secondary detection (SD) status"]
|
|
#[inline(always)]
|
|
pub const fn sdet(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Secondary detection (SD) status"]
|
|
#[inline(always)]
|
|
pub fn set_sdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "DM pull-up detection status"]
|
|
#[inline(always)]
|
|
pub const fn ps2det(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "DM pull-up detection status"]
|
|
#[inline(always)]
|
|
pub fn set_ps2det(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Power down"]
|
|
#[inline(always)]
|
|
pub const fn pwrdwn(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Power down"]
|
|
#[inline(always)]
|
|
pub fn set_pwrdwn(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "Battery charging detector (BCD) enable"]
|
|
#[inline(always)]
|
|
pub const fn bcden(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Battery charging detector (BCD) enable"]
|
|
#[inline(always)]
|
|
pub fn set_bcden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "Data contact detection (DCD) mode enable"]
|
|
#[inline(always)]
|
|
pub const fn dcden(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data contact detection (DCD) mode enable"]
|
|
#[inline(always)]
|
|
pub fn set_dcden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "Primary detection (PD) mode enable"]
|
|
#[inline(always)]
|
|
pub const fn pden(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Primary detection (PD) mode enable"]
|
|
#[inline(always)]
|
|
pub fn set_pden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "Secondary detection (SD) mode enable"]
|
|
#[inline(always)]
|
|
pub const fn sden(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Secondary detection (SD) mode enable"]
|
|
#[inline(always)]
|
|
pub fn set_sden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "USB VBUS detection enable"]
|
|
#[inline(always)]
|
|
pub const fn vbden(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USB VBUS detection enable"]
|
|
#[inline(always)]
|
|
pub fn set_vbden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "Internal high-speed PHY enable."]
|
|
#[inline(always)]
|
|
pub const fn phyhsen(&self) -> bool {
|
|
let val = (self.0 >> 23usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Internal high-speed PHY enable."]
|
|
#[inline(always)]
|
|
pub fn set_phyhsen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
|
|
}
|
|
}
|
|
impl Default for GccfgV2 {
|
|
#[inline(always)]
|
|
fn default() -> GccfgV2 {
|
|
GccfgV2(0)
|
|
}
|
|
}
|
|
#[doc = "OTG general core configuration register."]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct GccfgV3(pub u32);
|
|
impl GccfgV3 {
|
|
#[doc = "Charger detection, result of the current mode (primary or secondary)."]
|
|
#[inline(always)]
|
|
pub const fn chgdet(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Charger detection, result of the current mode (primary or secondary)."]
|
|
#[inline(always)]
|
|
pub fn set_chgdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Single-Ended DP indicator This bit gives the voltage level on DP (also result of the comparison with V<sub>LGC</sub> threshold as defined in BC v1.2 standard)."]
|
|
#[inline(always)]
|
|
pub const fn fsvplus(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Single-Ended DP indicator This bit gives the voltage level on DP (also result of the comparison with V<sub>LGC</sub> threshold as defined in BC v1.2 standard)."]
|
|
#[inline(always)]
|
|
pub fn set_fsvplus(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Single-Ended DM indicator This bit gives the voltage level on DM (also result of the comparison with V<sub>LGC</sub> threshold as defined in BC v1.2 standard)."]
|
|
#[inline(always)]
|
|
pub const fn fsvminus(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Single-Ended DM indicator This bit gives the voltage level on DM (also result of the comparison with V<sub>LGC</sub> threshold as defined in BC v1.2 standard)."]
|
|
#[inline(always)]
|
|
pub fn set_fsvminus(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "VBUS session indicator Indicates if VBUS is above VBUS session threshold."]
|
|
#[inline(always)]
|
|
pub const fn sessvld(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "VBUS session indicator Indicates if VBUS is above VBUS session threshold."]
|
|
#[inline(always)]
|
|
pub fn set_sessvld(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Host CDP behavior enable."]
|
|
#[inline(always)]
|
|
pub const fn hcdpen(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host CDP behavior enable."]
|
|
#[inline(always)]
|
|
pub fn set_hcdpen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "Host CDP port voltage detector enable on DP."]
|
|
#[inline(always)]
|
|
pub const fn hcdpdeten(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host CDP port voltage detector enable on DP."]
|
|
#[inline(always)]
|
|
pub fn set_hcdpdeten(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "Host CDP port Voltage source enable on DM."]
|
|
#[inline(always)]
|
|
pub const fn hvdmsrcen(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host CDP port Voltage source enable on DM."]
|
|
#[inline(always)]
|
|
pub fn set_hvdmsrcen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "Data Contact Detection enable."]
|
|
#[inline(always)]
|
|
pub const fn dcden(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data Contact Detection enable."]
|
|
#[inline(always)]
|
|
pub fn set_dcden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "Primary detection enable."]
|
|
#[inline(always)]
|
|
pub const fn pden(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Primary detection enable."]
|
|
#[inline(always)]
|
|
pub fn set_pden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "VBUS detection enable Enables VBUS Sensing Comparators in order to detect VBUS presence and/or perform OTG operation."]
|
|
#[inline(always)]
|
|
pub const fn vbden(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "VBUS detection enable Enables VBUS Sensing Comparators in order to detect VBUS presence and/or perform OTG operation."]
|
|
#[inline(always)]
|
|
pub fn set_vbden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "Secondary detection enable."]
|
|
#[inline(always)]
|
|
pub const fn sden(&self) -> bool {
|
|
let val = (self.0 >> 22usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Secondary detection enable."]
|
|
#[inline(always)]
|
|
pub fn set_sden(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
|
|
}
|
|
#[doc = "Software override value of the VBUS B-session detection."]
|
|
#[inline(always)]
|
|
pub const fn vbvaloval(&self) -> bool {
|
|
let val = (self.0 >> 23usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Software override value of the VBUS B-session detection."]
|
|
#[inline(always)]
|
|
pub fn set_vbvaloval(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
|
|
}
|
|
#[doc = "Enables a software override of the VBUS B-session detection."]
|
|
#[inline(always)]
|
|
pub const fn vbvaloven(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enables a software override of the VBUS B-session detection."]
|
|
#[inline(always)]
|
|
pub fn set_vbvaloven(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "Force host mode pull-downs If the ID pin functions are enabled, the host mode pull-downs on DP and DM activate automatically. However, whenever that is not the case, yet host mode is required, this bit must be used to force the pull-downs active."]
|
|
#[inline(always)]
|
|
pub const fn forcehostpd(&self) -> bool {
|
|
let val = (self.0 >> 25usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Force host mode pull-downs If the ID pin functions are enabled, the host mode pull-downs on DP and DM activate automatically. However, whenever that is not the case, yet host mode is required, this bit must be used to force the pull-downs active."]
|
|
#[inline(always)]
|
|
pub fn set_forcehostpd(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
|
|
}
|
|
}
|
|
impl Default for GccfgV3 {
|
|
#[inline(always)]
|
|
fn default() -> GccfgV3 {
|
|
GccfgV3(0)
|
|
}
|
|
}
|
|
#[doc = "I2C access register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gi2cctl(pub u32);
|
|
impl Gi2cctl {
|
|
#[doc = "I2C Read/Write Data"]
|
|
#[inline(always)]
|
|
pub const fn rwdata(&self) -> u8 {
|
|
let val = (self.0 >> 0usize) & 0xff;
|
|
val as u8
|
|
}
|
|
#[doc = "I2C Read/Write Data"]
|
|
#[inline(always)]
|
|
pub fn set_rwdata(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
|
|
}
|
|
#[doc = "I2C Register Address"]
|
|
#[inline(always)]
|
|
pub const fn regaddr(&self) -> u8 {
|
|
let val = (self.0 >> 8usize) & 0xff;
|
|
val as u8
|
|
}
|
|
#[doc = "I2C Register Address"]
|
|
#[inline(always)]
|
|
pub fn set_regaddr(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
|
|
}
|
|
#[doc = "I2C Address"]
|
|
#[inline(always)]
|
|
pub const fn addr(&self) -> u8 {
|
|
let val = (self.0 >> 16usize) & 0x7f;
|
|
val as u8
|
|
}
|
|
#[doc = "I2C Address"]
|
|
#[inline(always)]
|
|
pub fn set_addr(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x7f << 16usize)) | (((val as u32) & 0x7f) << 16usize);
|
|
}
|
|
#[doc = "I2C Enable"]
|
|
#[inline(always)]
|
|
pub const fn i2cen(&self) -> bool {
|
|
let val = (self.0 >> 23usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "I2C Enable"]
|
|
#[inline(always)]
|
|
pub fn set_i2cen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
|
|
}
|
|
#[doc = "I2C ACK"]
|
|
#[inline(always)]
|
|
pub const fn ack(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "I2C ACK"]
|
|
#[inline(always)]
|
|
pub fn set_ack(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "I2C Device Address"]
|
|
#[inline(always)]
|
|
pub const fn i2cdevadr(&self) -> u8 {
|
|
let val = (self.0 >> 26usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "I2C Device Address"]
|
|
#[inline(always)]
|
|
pub fn set_i2cdevadr(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 26usize)) | (((val as u32) & 0x03) << 26usize);
|
|
}
|
|
#[doc = "I2C DatSe0 USB mode"]
|
|
#[inline(always)]
|
|
pub const fn i2cdatse0(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "I2C DatSe0 USB mode"]
|
|
#[inline(always)]
|
|
pub fn set_i2cdatse0(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
#[doc = "Read/Write Indicator"]
|
|
#[inline(always)]
|
|
pub const fn rw(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Read/Write Indicator"]
|
|
#[inline(always)]
|
|
pub fn set_rw(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "I2C Busy/Done"]
|
|
#[inline(always)]
|
|
pub const fn bsydne(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "I2C Busy/Done"]
|
|
#[inline(always)]
|
|
pub fn set_bsydne(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Gi2cctl {
|
|
#[inline(always)]
|
|
fn default() -> Gi2cctl {
|
|
Gi2cctl(0)
|
|
}
|
|
}
|
|
#[doc = "Interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gintmsk(pub u32);
|
|
impl Gintmsk {
|
|
#[doc = "Mode mismatch interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn mmism(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Mode mismatch interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_mmism(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "OTG interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn otgint(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OTG interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_otgint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Start of frame mask"]
|
|
#[inline(always)]
|
|
pub const fn sofm(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Start of frame mask"]
|
|
#[inline(always)]
|
|
pub fn set_sofm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Receive FIFO non-empty mask"]
|
|
#[inline(always)]
|
|
pub const fn rxflvlm(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Receive FIFO non-empty mask"]
|
|
#[inline(always)]
|
|
pub fn set_rxflvlm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "Non-periodic TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub const fn nptxfem(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Non-periodic TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub fn set_nptxfem(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "Global non-periodic IN NAK effective mask"]
|
|
#[inline(always)]
|
|
pub const fn ginakeffm(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global non-periodic IN NAK effective mask"]
|
|
#[inline(always)]
|
|
pub fn set_ginakeffm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "Global OUT NAK effective mask"]
|
|
#[inline(always)]
|
|
pub const fn gonakeffm(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global OUT NAK effective mask"]
|
|
#[inline(always)]
|
|
pub fn set_gonakeffm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Early suspend mask"]
|
|
#[inline(always)]
|
|
pub const fn esuspm(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Early suspend mask"]
|
|
#[inline(always)]
|
|
pub fn set_esuspm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
#[doc = "USB suspend mask"]
|
|
#[inline(always)]
|
|
pub const fn usbsuspm(&self) -> bool {
|
|
let val = (self.0 >> 11usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USB suspend mask"]
|
|
#[inline(always)]
|
|
pub fn set_usbsuspm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
|
|
}
|
|
#[doc = "USB reset mask"]
|
|
#[inline(always)]
|
|
pub const fn usbrst(&self) -> bool {
|
|
let val = (self.0 >> 12usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USB reset mask"]
|
|
#[inline(always)]
|
|
pub fn set_usbrst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
|
|
}
|
|
#[doc = "Enumeration done mask"]
|
|
#[inline(always)]
|
|
pub const fn enumdnem(&self) -> bool {
|
|
let val = (self.0 >> 13usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enumeration done mask"]
|
|
#[inline(always)]
|
|
pub fn set_enumdnem(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
|
|
}
|
|
#[doc = "Isochronous OUT packet dropped interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn isoodrpm(&self) -> bool {
|
|
let val = (self.0 >> 14usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Isochronous OUT packet dropped interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_isoodrpm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
|
|
}
|
|
#[doc = "End of periodic frame interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn eopfm(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "End of periodic frame interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_eopfm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "Endpoint mismatch interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn epmism(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Endpoint mismatch interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_epmism(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "IN endpoints interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn iepint(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "IN endpoints interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_iepint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "OUT endpoints interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn oepint(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OUT endpoints interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_oepint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "Incomplete isochronous IN transfer mask"]
|
|
#[inline(always)]
|
|
pub const fn iisoixfrm(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Incomplete isochronous IN transfer mask"]
|
|
#[inline(always)]
|
|
pub fn set_iisoixfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "Incomplete periodic transfer mask (host mode) / Incomplete isochronous OUT transfer mask (device mode)"]
|
|
#[inline(always)]
|
|
pub const fn ipxfrm_iisooxfrm(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Incomplete periodic transfer mask (host mode) / Incomplete isochronous OUT transfer mask (device mode)"]
|
|
#[inline(always)]
|
|
pub fn set_ipxfrm_iisooxfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "Data fetch suspended mask"]
|
|
#[inline(always)]
|
|
pub const fn fsuspm(&self) -> bool {
|
|
let val = (self.0 >> 22usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data fetch suspended mask"]
|
|
#[inline(always)]
|
|
pub fn set_fsuspm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
|
|
}
|
|
#[doc = "Reset detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn rstde(&self) -> bool {
|
|
let val = (self.0 >> 23usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Reset detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_rstde(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
|
|
}
|
|
#[doc = "Host port interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn prtim(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host port interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_prtim(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "Host channels interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn hcim(&self) -> bool {
|
|
let val = (self.0 >> 25usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host channels interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_hcim(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
|
|
}
|
|
#[doc = "Periodic TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub const fn ptxfem(&self) -> bool {
|
|
let val = (self.0 >> 26usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Periodic TxFIFO empty mask"]
|
|
#[inline(always)]
|
|
pub fn set_ptxfem(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
|
|
}
|
|
#[doc = "LPM interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn lpmintm(&self) -> bool {
|
|
let val = (self.0 >> 27usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "LPM interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_lpmintm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
|
|
}
|
|
#[doc = "Connector ID status change mask"]
|
|
#[inline(always)]
|
|
pub const fn cidschgm(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Connector ID status change mask"]
|
|
#[inline(always)]
|
|
pub fn set_cidschgm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
#[doc = "Disconnect detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn discint(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Disconnect detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_discint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "Session request/new session detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn srqim(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session request/new session detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_srqim(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "Resume/remote wakeup detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn wuim(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Resume/remote wakeup detected interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_wuim(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Gintmsk {
|
|
#[inline(always)]
|
|
fn default() -> Gintmsk {
|
|
Gintmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Core interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gintsts(pub u32);
|
|
impl Gintsts {
|
|
#[doc = "Current mode of operation"]
|
|
#[inline(always)]
|
|
pub const fn cmod(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Current mode of operation"]
|
|
#[inline(always)]
|
|
pub fn set_cmod(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Mode mismatch interrupt"]
|
|
#[inline(always)]
|
|
pub const fn mmis(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Mode mismatch interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_mmis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "OTG interrupt"]
|
|
#[inline(always)]
|
|
pub const fn otgint(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OTG interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_otgint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Start of frame"]
|
|
#[inline(always)]
|
|
pub const fn sof(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Start of frame"]
|
|
#[inline(always)]
|
|
pub fn set_sof(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "RxFIFO non-empty"]
|
|
#[inline(always)]
|
|
pub const fn rxflvl(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "RxFIFO non-empty"]
|
|
#[inline(always)]
|
|
pub fn set_rxflvl(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "Non-periodic TxFIFO empty"]
|
|
#[inline(always)]
|
|
pub const fn nptxfe(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Non-periodic TxFIFO empty"]
|
|
#[inline(always)]
|
|
pub fn set_nptxfe(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "Global IN non-periodic NAK effective"]
|
|
#[inline(always)]
|
|
pub const fn ginakeff(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global IN non-periodic NAK effective"]
|
|
#[inline(always)]
|
|
pub fn set_ginakeff(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "Global OUT NAK effective"]
|
|
#[inline(always)]
|
|
pub const fn goutnakeff(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Global OUT NAK effective"]
|
|
#[inline(always)]
|
|
pub fn set_goutnakeff(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Early suspend"]
|
|
#[inline(always)]
|
|
pub const fn esusp(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Early suspend"]
|
|
#[inline(always)]
|
|
pub fn set_esusp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
#[doc = "USB suspend"]
|
|
#[inline(always)]
|
|
pub const fn usbsusp(&self) -> bool {
|
|
let val = (self.0 >> 11usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USB suspend"]
|
|
#[inline(always)]
|
|
pub fn set_usbsusp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
|
|
}
|
|
#[doc = "USB reset"]
|
|
#[inline(always)]
|
|
pub const fn usbrst(&self) -> bool {
|
|
let val = (self.0 >> 12usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "USB reset"]
|
|
#[inline(always)]
|
|
pub fn set_usbrst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
|
|
}
|
|
#[doc = "Enumeration done"]
|
|
#[inline(always)]
|
|
pub const fn enumdne(&self) -> bool {
|
|
let val = (self.0 >> 13usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enumeration done"]
|
|
#[inline(always)]
|
|
pub fn set_enumdne(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
|
|
}
|
|
#[doc = "Isochronous OUT packet dropped interrupt"]
|
|
#[inline(always)]
|
|
pub const fn isoodrp(&self) -> bool {
|
|
let val = (self.0 >> 14usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Isochronous OUT packet dropped interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_isoodrp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
|
|
}
|
|
#[doc = "End of periodic frame interrupt"]
|
|
#[inline(always)]
|
|
pub const fn eopf(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "End of periodic frame interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_eopf(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "IN endpoint interrupt"]
|
|
#[inline(always)]
|
|
pub const fn iepint(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "IN endpoint interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_iepint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "OUT endpoint interrupt"]
|
|
#[inline(always)]
|
|
pub const fn oepint(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "OUT endpoint interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_oepint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "Incomplete isochronous IN transfer"]
|
|
#[inline(always)]
|
|
pub const fn iisoixfr(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Incomplete isochronous IN transfer"]
|
|
#[inline(always)]
|
|
pub fn set_iisoixfr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "Incomplete periodic transfer (host mode) / Incomplete isochronous OUT transfer (device mode)"]
|
|
#[inline(always)]
|
|
pub const fn ipxfr_incompisoout(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Incomplete periodic transfer (host mode) / Incomplete isochronous OUT transfer (device mode)"]
|
|
#[inline(always)]
|
|
pub fn set_ipxfr_incompisoout(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "Data fetch suspended"]
|
|
#[inline(always)]
|
|
pub const fn datafsusp(&self) -> bool {
|
|
let val = (self.0 >> 22usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data fetch suspended"]
|
|
#[inline(always)]
|
|
pub fn set_datafsusp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
|
|
}
|
|
#[doc = "Host port interrupt"]
|
|
#[inline(always)]
|
|
pub const fn hprtint(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host port interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_hprtint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "Host channels interrupt"]
|
|
#[inline(always)]
|
|
pub const fn hcint(&self) -> bool {
|
|
let val = (self.0 >> 25usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host channels interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_hcint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
|
|
}
|
|
#[doc = "Periodic TxFIFO empty"]
|
|
#[inline(always)]
|
|
pub const fn ptxfe(&self) -> bool {
|
|
let val = (self.0 >> 26usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Periodic TxFIFO empty"]
|
|
#[inline(always)]
|
|
pub fn set_ptxfe(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
|
|
}
|
|
#[doc = "Connector ID status change"]
|
|
#[inline(always)]
|
|
pub const fn cidschg(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Connector ID status change"]
|
|
#[inline(always)]
|
|
pub fn set_cidschg(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
#[doc = "Disconnect detected interrupt"]
|
|
#[inline(always)]
|
|
pub const fn discint(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Disconnect detected interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_discint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "Session request/new session detected interrupt"]
|
|
#[inline(always)]
|
|
pub const fn srqint(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session request/new session detected interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_srqint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "Resume/remote wakeup detected interrupt"]
|
|
#[inline(always)]
|
|
pub const fn wkupint(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Resume/remote wakeup detected interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_wkupint(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Gintsts {
|
|
#[inline(always)]
|
|
fn default() -> Gintsts {
|
|
Gintsts(0)
|
|
}
|
|
}
|
|
#[doc = "Core LPM configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Glpmcfg(pub u32);
|
|
impl Glpmcfg {
|
|
#[doc = "LPM support enable"]
|
|
#[inline(always)]
|
|
pub const fn lpmen(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "LPM support enable"]
|
|
#[inline(always)]
|
|
pub fn set_lpmen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "LPM token acknowledge enable"]
|
|
#[inline(always)]
|
|
pub const fn lpmack(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "LPM token acknowledge enable"]
|
|
#[inline(always)]
|
|
pub fn set_lpmack(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Best effort service latency"]
|
|
#[inline(always)]
|
|
pub const fn besl(&self) -> u8 {
|
|
let val = (self.0 >> 2usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Best effort service latency"]
|
|
#[inline(always)]
|
|
pub fn set_besl(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 2usize)) | (((val as u32) & 0x0f) << 2usize);
|
|
}
|
|
#[doc = "bRemoteWake value"]
|
|
#[inline(always)]
|
|
pub const fn remwake(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "bRemoteWake value"]
|
|
#[inline(always)]
|
|
pub fn set_remwake(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "L1 Shallow Sleep enable"]
|
|
#[inline(always)]
|
|
pub const fn l1ssen(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "L1 Shallow Sleep enable"]
|
|
#[inline(always)]
|
|
pub fn set_l1ssen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "BESL threshold"]
|
|
#[inline(always)]
|
|
pub const fn beslthrs(&self) -> u8 {
|
|
let val = (self.0 >> 8usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "BESL threshold"]
|
|
#[inline(always)]
|
|
pub fn set_beslthrs(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
|
|
}
|
|
#[doc = "L1 deep sleep enable"]
|
|
#[inline(always)]
|
|
pub const fn l1dsen(&self) -> bool {
|
|
let val = (self.0 >> 12usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "L1 deep sleep enable"]
|
|
#[inline(always)]
|
|
pub fn set_l1dsen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
|
|
}
|
|
#[doc = "LPM response"]
|
|
#[inline(always)]
|
|
pub const fn lpmrst(&self) -> u8 {
|
|
let val = (self.0 >> 13usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "LPM response"]
|
|
#[inline(always)]
|
|
pub fn set_lpmrst(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 13usize)) | (((val as u32) & 0x03) << 13usize);
|
|
}
|
|
#[doc = "Port sleep status"]
|
|
#[inline(always)]
|
|
pub const fn slpsts(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port sleep status"]
|
|
#[inline(always)]
|
|
pub fn set_slpsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "Sleep State Resume OK"]
|
|
#[inline(always)]
|
|
pub const fn l1rsmok(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Sleep State Resume OK"]
|
|
#[inline(always)]
|
|
pub fn set_l1rsmok(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "LPM Channel Index"]
|
|
#[inline(always)]
|
|
pub const fn lpmchidx(&self) -> u8 {
|
|
let val = (self.0 >> 17usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "LPM Channel Index"]
|
|
#[inline(always)]
|
|
pub fn set_lpmchidx(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 17usize)) | (((val as u32) & 0x0f) << 17usize);
|
|
}
|
|
#[doc = "LPM retry count"]
|
|
#[inline(always)]
|
|
pub const fn lpmrcnt(&self) -> u8 {
|
|
let val = (self.0 >> 21usize) & 0x07;
|
|
val as u8
|
|
}
|
|
#[doc = "LPM retry count"]
|
|
#[inline(always)]
|
|
pub fn set_lpmrcnt(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x07 << 21usize)) | (((val as u32) & 0x07) << 21usize);
|
|
}
|
|
#[doc = "Send LPM transaction"]
|
|
#[inline(always)]
|
|
pub const fn sndlpm(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Send LPM transaction"]
|
|
#[inline(always)]
|
|
pub fn set_sndlpm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "LPM retry count status"]
|
|
#[inline(always)]
|
|
pub const fn lpmrcntsts(&self) -> u8 {
|
|
let val = (self.0 >> 25usize) & 0x07;
|
|
val as u8
|
|
}
|
|
#[doc = "LPM retry count status"]
|
|
#[inline(always)]
|
|
pub fn set_lpmrcntsts(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x07 << 25usize)) | (((val as u32) & 0x07) << 25usize);
|
|
}
|
|
#[doc = "Enable best effort service latency"]
|
|
#[inline(always)]
|
|
pub const fn enbesl(&self) -> bool {
|
|
let val = (self.0 >> 28usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Enable best effort service latency"]
|
|
#[inline(always)]
|
|
pub fn set_enbesl(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
|
|
}
|
|
}
|
|
impl Default for Glpmcfg {
|
|
#[inline(always)]
|
|
fn default() -> Glpmcfg {
|
|
Glpmcfg(0)
|
|
}
|
|
}
|
|
#[doc = "Control and status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gotgctl(pub u32);
|
|
impl Gotgctl {
|
|
#[doc = "Session request success"]
|
|
#[inline(always)]
|
|
pub const fn srqscs(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session request success"]
|
|
#[inline(always)]
|
|
pub fn set_srqscs(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Session request"]
|
|
#[inline(always)]
|
|
pub const fn srq(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session request"]
|
|
#[inline(always)]
|
|
pub fn set_srq(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "VBUS valid override enable"]
|
|
#[inline(always)]
|
|
pub const fn vbvaloen(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "VBUS valid override enable"]
|
|
#[inline(always)]
|
|
pub fn set_vbvaloen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "VBUS valid override value"]
|
|
#[inline(always)]
|
|
pub const fn vbvaloval(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "VBUS valid override value"]
|
|
#[inline(always)]
|
|
pub fn set_vbvaloval(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "A-peripheral session valid override enable"]
|
|
#[inline(always)]
|
|
pub const fn avaloen(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "A-peripheral session valid override enable"]
|
|
#[inline(always)]
|
|
pub fn set_avaloen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "A-peripheral session valid override value"]
|
|
#[inline(always)]
|
|
pub const fn avaloval(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "A-peripheral session valid override value"]
|
|
#[inline(always)]
|
|
pub fn set_avaloval(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "B-peripheral session valid override enable"]
|
|
#[inline(always)]
|
|
pub const fn bvaloen(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "B-peripheral session valid override enable"]
|
|
#[inline(always)]
|
|
pub fn set_bvaloen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "B-peripheral session valid override value"]
|
|
#[inline(always)]
|
|
pub const fn bvaloval(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "B-peripheral session valid override value"]
|
|
#[inline(always)]
|
|
pub fn set_bvaloval(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Host negotiation success"]
|
|
#[inline(always)]
|
|
pub const fn hngscs(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host negotiation success"]
|
|
#[inline(always)]
|
|
pub fn set_hngscs(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "HNP request"]
|
|
#[inline(always)]
|
|
pub const fn hnprq(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "HNP request"]
|
|
#[inline(always)]
|
|
pub fn set_hnprq(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "Host set HNP enable"]
|
|
#[inline(always)]
|
|
pub const fn hshnpen(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host set HNP enable"]
|
|
#[inline(always)]
|
|
pub fn set_hshnpen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
#[doc = "Device HNP enabled"]
|
|
#[inline(always)]
|
|
pub const fn dhnpen(&self) -> bool {
|
|
let val = (self.0 >> 11usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Device HNP enabled"]
|
|
#[inline(always)]
|
|
pub fn set_dhnpen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
|
|
}
|
|
#[doc = "Embedded host enable"]
|
|
#[inline(always)]
|
|
pub const fn ehen(&self) -> bool {
|
|
let val = (self.0 >> 12usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Embedded host enable"]
|
|
#[inline(always)]
|
|
pub fn set_ehen(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
|
|
}
|
|
#[doc = "Connector ID status"]
|
|
#[inline(always)]
|
|
pub const fn cidsts(&self) -> bool {
|
|
let val = (self.0 >> 16usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Connector ID status"]
|
|
#[inline(always)]
|
|
pub fn set_cidsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
|
|
}
|
|
#[doc = "Long/short debounce time"]
|
|
#[inline(always)]
|
|
pub const fn dbct(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Long/short debounce time"]
|
|
#[inline(always)]
|
|
pub fn set_dbct(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "A-session valid"]
|
|
#[inline(always)]
|
|
pub const fn asvld(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "A-session valid"]
|
|
#[inline(always)]
|
|
pub fn set_asvld(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "B-session valid"]
|
|
#[inline(always)]
|
|
pub const fn bsvld(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "B-session valid"]
|
|
#[inline(always)]
|
|
pub fn set_bsvld(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
}
|
|
impl Default for Gotgctl {
|
|
#[inline(always)]
|
|
fn default() -> Gotgctl {
|
|
Gotgctl(0)
|
|
}
|
|
}
|
|
#[doc = "Interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gotgint(pub u32);
|
|
impl Gotgint {
|
|
#[doc = "Session end detected"]
|
|
#[inline(always)]
|
|
pub const fn sedet(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session end detected"]
|
|
#[inline(always)]
|
|
pub fn set_sedet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Session request success status change"]
|
|
#[inline(always)]
|
|
pub const fn srsschg(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Session request success status change"]
|
|
#[inline(always)]
|
|
pub fn set_srsschg(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "Host negotiation success status change"]
|
|
#[inline(always)]
|
|
pub const fn hnsschg(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host negotiation success status change"]
|
|
#[inline(always)]
|
|
pub fn set_hnsschg(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "Host negotiation detected"]
|
|
#[inline(always)]
|
|
pub const fn hngdet(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host negotiation detected"]
|
|
#[inline(always)]
|
|
pub fn set_hngdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "A-device timeout change"]
|
|
#[inline(always)]
|
|
pub const fn adtochg(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "A-device timeout change"]
|
|
#[inline(always)]
|
|
pub fn set_adtochg(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "Debounce done"]
|
|
#[inline(always)]
|
|
pub const fn dbcdne(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Debounce done"]
|
|
#[inline(always)]
|
|
pub fn set_dbcdne(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "ID input pin changed"]
|
|
#[inline(always)]
|
|
pub const fn idchng(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ID input pin changed"]
|
|
#[inline(always)]
|
|
pub fn set_idchng(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
}
|
|
impl Default for Gotgint {
|
|
#[inline(always)]
|
|
fn default() -> Gotgint {
|
|
Gotgint(0)
|
|
}
|
|
}
|
|
#[doc = "Reset register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Grstctl(pub u32);
|
|
impl Grstctl {
|
|
#[doc = "Core soft reset"]
|
|
#[inline(always)]
|
|
pub const fn csrst(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Core soft reset"]
|
|
#[inline(always)]
|
|
pub fn set_csrst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "HCLK soft reset"]
|
|
#[inline(always)]
|
|
pub const fn hsrst(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "HCLK soft reset"]
|
|
#[inline(always)]
|
|
pub fn set_hsrst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Host frame counter reset"]
|
|
#[inline(always)]
|
|
pub const fn fcrst(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Host frame counter reset"]
|
|
#[inline(always)]
|
|
pub fn set_fcrst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "RxFIFO flush"]
|
|
#[inline(always)]
|
|
pub const fn rxfflsh(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "RxFIFO flush"]
|
|
#[inline(always)]
|
|
pub fn set_rxfflsh(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "TxFIFO flush"]
|
|
#[inline(always)]
|
|
pub const fn txfflsh(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "TxFIFO flush"]
|
|
#[inline(always)]
|
|
pub fn set_txfflsh(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "TxFIFO number"]
|
|
#[inline(always)]
|
|
pub const fn txfnum(&self) -> u8 {
|
|
let val = (self.0 >> 6usize) & 0x1f;
|
|
val as u8
|
|
}
|
|
#[doc = "TxFIFO number"]
|
|
#[inline(always)]
|
|
pub fn set_txfnum(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x1f << 6usize)) | (((val as u32) & 0x1f) << 6usize);
|
|
}
|
|
#[doc = "DMA request signal enabled for USB OTG HS"]
|
|
#[inline(always)]
|
|
pub const fn dmareq(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "DMA request signal enabled for USB OTG HS"]
|
|
#[inline(always)]
|
|
pub fn set_dmareq(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "AHB master idle"]
|
|
#[inline(always)]
|
|
pub const fn ahbidl(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "AHB master idle"]
|
|
#[inline(always)]
|
|
pub fn set_ahbidl(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Grstctl {
|
|
#[inline(always)]
|
|
fn default() -> Grstctl {
|
|
Grstctl(0)
|
|
}
|
|
}
|
|
#[doc = "Receive FIFO size register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Grxfsiz(pub u32);
|
|
impl Grxfsiz {
|
|
#[doc = "RxFIFO depth"]
|
|
#[inline(always)]
|
|
pub const fn rxfd(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "RxFIFO depth"]
|
|
#[inline(always)]
|
|
pub fn set_rxfd(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Grxfsiz {
|
|
#[inline(always)]
|
|
fn default() -> Grxfsiz {
|
|
Grxfsiz(0)
|
|
}
|
|
}
|
|
#[doc = "Status read and pop register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Grxsts(pub u32);
|
|
impl Grxsts {
|
|
#[doc = "Endpoint number (device mode) / Channel number (host mode)"]
|
|
#[inline(always)]
|
|
pub const fn epnum(&self) -> u8 {
|
|
let val = (self.0 >> 0usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Endpoint number (device mode) / Channel number (host mode)"]
|
|
#[inline(always)]
|
|
pub fn set_epnum(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
|
|
}
|
|
#[doc = "Byte count"]
|
|
#[inline(always)]
|
|
pub const fn bcnt(&self) -> u16 {
|
|
let val = (self.0 >> 4usize) & 0x07ff;
|
|
val as u16
|
|
}
|
|
#[doc = "Byte count"]
|
|
#[inline(always)]
|
|
pub fn set_bcnt(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x07ff << 4usize)) | (((val as u32) & 0x07ff) << 4usize);
|
|
}
|
|
#[doc = "Data PID"]
|
|
#[inline(always)]
|
|
pub const fn dpid(&self) -> super::vals::Dpid {
|
|
let val = (self.0 >> 15usize) & 0x03;
|
|
super::vals::Dpid::from_bits(val as u8)
|
|
}
|
|
#[doc = "Data PID"]
|
|
#[inline(always)]
|
|
pub fn set_dpid(&mut self, val: super::vals::Dpid) {
|
|
self.0 = (self.0 & !(0x03 << 15usize)) | (((val.to_bits() as u32) & 0x03) << 15usize);
|
|
}
|
|
#[doc = "Packet status (device mode)"]
|
|
#[inline(always)]
|
|
pub const fn pktstsd(&self) -> super::vals::Pktstsd {
|
|
let val = (self.0 >> 17usize) & 0x0f;
|
|
super::vals::Pktstsd::from_bits(val as u8)
|
|
}
|
|
#[doc = "Packet status (device mode)"]
|
|
#[inline(always)]
|
|
pub fn set_pktstsd(&mut self, val: super::vals::Pktstsd) {
|
|
self.0 = (self.0 & !(0x0f << 17usize)) | (((val.to_bits() as u32) & 0x0f) << 17usize);
|
|
}
|
|
#[doc = "Packet status (host mode)"]
|
|
#[inline(always)]
|
|
pub const fn pktstsh(&self) -> super::vals::Pktstsh {
|
|
let val = (self.0 >> 17usize) & 0x0f;
|
|
super::vals::Pktstsh::from_bits(val as u8)
|
|
}
|
|
#[doc = "Packet status (host mode)"]
|
|
#[inline(always)]
|
|
pub fn set_pktstsh(&mut self, val: super::vals::Pktstsh) {
|
|
self.0 = (self.0 & !(0x0f << 17usize)) | (((val.to_bits() as u32) & 0x0f) << 17usize);
|
|
}
|
|
#[doc = "Frame number (device mode)"]
|
|
#[inline(always)]
|
|
pub const fn frmnum(&self) -> u8 {
|
|
let val = (self.0 >> 21usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Frame number (device mode)"]
|
|
#[inline(always)]
|
|
pub fn set_frmnum(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 21usize)) | (((val as u32) & 0x0f) << 21usize);
|
|
}
|
|
}
|
|
impl Default for Grxsts {
|
|
#[inline(always)]
|
|
fn default() -> Grxsts {
|
|
Grxsts(0)
|
|
}
|
|
}
|
|
#[doc = "USB configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Gusbcfg(pub u32);
|
|
impl Gusbcfg {
|
|
#[doc = "FS timeout calibration"]
|
|
#[inline(always)]
|
|
pub const fn tocal(&self) -> u8 {
|
|
let val = (self.0 >> 0usize) & 0x07;
|
|
val as u8
|
|
}
|
|
#[doc = "FS timeout calibration"]
|
|
#[inline(always)]
|
|
pub fn set_tocal(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x07 << 0usize)) | (((val as u32) & 0x07) << 0usize);
|
|
}
|
|
#[doc = "Full-speed internal serial transceiver enable"]
|
|
#[inline(always)]
|
|
pub const fn physel(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Full-speed internal serial transceiver enable"]
|
|
#[inline(always)]
|
|
pub fn set_physel(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "SRP-capable"]
|
|
#[inline(always)]
|
|
pub const fn srpcap(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "SRP-capable"]
|
|
#[inline(always)]
|
|
pub fn set_srpcap(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "HNP-capable"]
|
|
#[inline(always)]
|
|
pub const fn hnpcap(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "HNP-capable"]
|
|
#[inline(always)]
|
|
pub fn set_hnpcap(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "USB turnaround time"]
|
|
#[inline(always)]
|
|
pub const fn trdt(&self) -> u8 {
|
|
let val = (self.0 >> 10usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "USB turnaround time"]
|
|
#[inline(always)]
|
|
pub fn set_trdt(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 10usize)) | (((val as u32) & 0x0f) << 10usize);
|
|
}
|
|
#[doc = "PHY Low-power clock select"]
|
|
#[inline(always)]
|
|
pub const fn phylpcs(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "PHY Low-power clock select"]
|
|
#[inline(always)]
|
|
pub fn set_phylpcs(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "ULPI FS/LS select"]
|
|
#[inline(always)]
|
|
pub const fn ulpifsls(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI FS/LS select"]
|
|
#[inline(always)]
|
|
pub fn set_ulpifsls(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "ULPI Auto-resume"]
|
|
#[inline(always)]
|
|
pub const fn ulpiar(&self) -> bool {
|
|
let val = (self.0 >> 18usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI Auto-resume"]
|
|
#[inline(always)]
|
|
pub fn set_ulpiar(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
|
|
}
|
|
#[doc = "ULPI Clock SuspendM"]
|
|
#[inline(always)]
|
|
pub const fn ulpicsm(&self) -> bool {
|
|
let val = (self.0 >> 19usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI Clock SuspendM"]
|
|
#[inline(always)]
|
|
pub fn set_ulpicsm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
|
|
}
|
|
#[doc = "ULPI External VBUS Drive"]
|
|
#[inline(always)]
|
|
pub const fn ulpievbusd(&self) -> bool {
|
|
let val = (self.0 >> 20usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI External VBUS Drive"]
|
|
#[inline(always)]
|
|
pub fn set_ulpievbusd(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
|
|
}
|
|
#[doc = "ULPI external VBUS indicator"]
|
|
#[inline(always)]
|
|
pub const fn ulpievbusi(&self) -> bool {
|
|
let val = (self.0 >> 21usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI external VBUS indicator"]
|
|
#[inline(always)]
|
|
pub fn set_ulpievbusi(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
|
|
}
|
|
#[doc = "TermSel DLine pulsing selection"]
|
|
#[inline(always)]
|
|
pub const fn tsdps(&self) -> bool {
|
|
let val = (self.0 >> 22usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "TermSel DLine pulsing selection"]
|
|
#[inline(always)]
|
|
pub fn set_tsdps(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
|
|
}
|
|
#[doc = "Indicator complement"]
|
|
#[inline(always)]
|
|
pub const fn pcci(&self) -> bool {
|
|
let val = (self.0 >> 23usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Indicator complement"]
|
|
#[inline(always)]
|
|
pub fn set_pcci(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
|
|
}
|
|
#[doc = "Indicator pass through"]
|
|
#[inline(always)]
|
|
pub const fn ptci(&self) -> bool {
|
|
let val = (self.0 >> 24usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Indicator pass through"]
|
|
#[inline(always)]
|
|
pub fn set_ptci(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
|
|
}
|
|
#[doc = "ULPI interface protect disable"]
|
|
#[inline(always)]
|
|
pub const fn ulpiipd(&self) -> bool {
|
|
let val = (self.0 >> 25usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ULPI interface protect disable"]
|
|
#[inline(always)]
|
|
pub fn set_ulpiipd(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
|
|
}
|
|
#[doc = "Force host mode"]
|
|
#[inline(always)]
|
|
pub const fn fhmod(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Force host mode"]
|
|
#[inline(always)]
|
|
pub fn set_fhmod(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "Force device mode"]
|
|
#[inline(always)]
|
|
pub const fn fdmod(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Force device mode"]
|
|
#[inline(always)]
|
|
pub fn set_fdmod(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "Corrupt Tx packet"]
|
|
#[inline(always)]
|
|
pub const fn ctxpkt(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Corrupt Tx packet"]
|
|
#[inline(always)]
|
|
pub fn set_ctxpkt(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Gusbcfg {
|
|
#[inline(always)]
|
|
fn default() -> Gusbcfg {
|
|
Gusbcfg(0)
|
|
}
|
|
}
|
|
#[doc = "Host all channels interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Haint(pub u32);
|
|
impl Haint {
|
|
#[doc = "Channel interrupts"]
|
|
#[inline(always)]
|
|
pub const fn haint(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Channel interrupts"]
|
|
#[inline(always)]
|
|
pub fn set_haint(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Haint {
|
|
#[inline(always)]
|
|
fn default() -> Haint {
|
|
Haint(0)
|
|
}
|
|
}
|
|
#[doc = "Host all channels interrupt mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Haintmsk(pub u32);
|
|
impl Haintmsk {
|
|
#[doc = "Channel interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn haintm(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Channel interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_haintm(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Haintmsk {
|
|
#[inline(always)]
|
|
fn default() -> Haintmsk {
|
|
Haintmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Host channel characteristics register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hcchar(pub u32);
|
|
impl Hcchar {
|
|
#[doc = "Maximum packet size"]
|
|
#[inline(always)]
|
|
pub const fn mpsiz(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0x07ff;
|
|
val as u16
|
|
}
|
|
#[doc = "Maximum packet size"]
|
|
#[inline(always)]
|
|
pub fn set_mpsiz(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x07ff << 0usize)) | (((val as u32) & 0x07ff) << 0usize);
|
|
}
|
|
#[doc = "Endpoint number"]
|
|
#[inline(always)]
|
|
pub const fn epnum(&self) -> u8 {
|
|
let val = (self.0 >> 11usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Endpoint number"]
|
|
#[inline(always)]
|
|
pub fn set_epnum(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 11usize)) | (((val as u32) & 0x0f) << 11usize);
|
|
}
|
|
#[doc = "Endpoint direction"]
|
|
#[inline(always)]
|
|
pub const fn epdir(&self) -> bool {
|
|
let val = (self.0 >> 15usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Endpoint direction"]
|
|
#[inline(always)]
|
|
pub fn set_epdir(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
|
|
}
|
|
#[doc = "Low-speed device"]
|
|
#[inline(always)]
|
|
pub const fn lsdev(&self) -> bool {
|
|
let val = (self.0 >> 17usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Low-speed device"]
|
|
#[inline(always)]
|
|
pub fn set_lsdev(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
|
|
}
|
|
#[doc = "Endpoint type"]
|
|
#[inline(always)]
|
|
pub const fn eptyp(&self) -> super::vals::Eptyp {
|
|
let val = (self.0 >> 18usize) & 0x03;
|
|
super::vals::Eptyp::from_bits(val as u8)
|
|
}
|
|
#[doc = "Endpoint type"]
|
|
#[inline(always)]
|
|
pub fn set_eptyp(&mut self, val: super::vals::Eptyp) {
|
|
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
|
|
}
|
|
#[doc = "Multicount"]
|
|
#[inline(always)]
|
|
pub const fn mcnt(&self) -> u8 {
|
|
let val = (self.0 >> 20usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Multicount"]
|
|
#[inline(always)]
|
|
pub fn set_mcnt(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 20usize)) | (((val as u32) & 0x03) << 20usize);
|
|
}
|
|
#[doc = "Device address"]
|
|
#[inline(always)]
|
|
pub const fn dad(&self) -> u8 {
|
|
let val = (self.0 >> 22usize) & 0x7f;
|
|
val as u8
|
|
}
|
|
#[doc = "Device address"]
|
|
#[inline(always)]
|
|
pub fn set_dad(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x7f << 22usize)) | (((val as u32) & 0x7f) << 22usize);
|
|
}
|
|
#[doc = "Odd frame"]
|
|
#[inline(always)]
|
|
pub const fn oddfrm(&self) -> bool {
|
|
let val = (self.0 >> 29usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Odd frame"]
|
|
#[inline(always)]
|
|
pub fn set_oddfrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
|
|
}
|
|
#[doc = "Channel disable"]
|
|
#[inline(always)]
|
|
pub const fn chdis(&self) -> bool {
|
|
let val = (self.0 >> 30usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Channel disable"]
|
|
#[inline(always)]
|
|
pub fn set_chdis(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
|
|
}
|
|
#[doc = "Channel enable"]
|
|
#[inline(always)]
|
|
pub const fn chena(&self) -> bool {
|
|
let val = (self.0 >> 31usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Channel enable"]
|
|
#[inline(always)]
|
|
pub fn set_chena(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
|
|
}
|
|
}
|
|
impl Default for Hcchar {
|
|
#[inline(always)]
|
|
fn default() -> Hcchar {
|
|
Hcchar(0)
|
|
}
|
|
}
|
|
#[doc = "Host configuration register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hcfg(pub u32);
|
|
impl Hcfg {
|
|
#[doc = "FS/LS PHY clock select"]
|
|
#[inline(always)]
|
|
pub const fn fslspcs(&self) -> u8 {
|
|
let val = (self.0 >> 0usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "FS/LS PHY clock select"]
|
|
#[inline(always)]
|
|
pub fn set_fslspcs(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 0usize)) | (((val as u32) & 0x03) << 0usize);
|
|
}
|
|
#[doc = "FS- and LS-only support"]
|
|
#[inline(always)]
|
|
pub const fn fslss(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "FS- and LS-only support"]
|
|
#[inline(always)]
|
|
pub fn set_fslss(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
}
|
|
impl Default for Hcfg {
|
|
#[inline(always)]
|
|
fn default() -> Hcfg {
|
|
Hcfg(0)
|
|
}
|
|
}
|
|
#[doc = "Host channel interrupt register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hcint(pub u32);
|
|
impl Hcint {
|
|
#[doc = "Transfer completed"]
|
|
#[inline(always)]
|
|
pub const fn xfrc(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transfer completed"]
|
|
#[inline(always)]
|
|
pub fn set_xfrc(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Channel halted"]
|
|
#[inline(always)]
|
|
pub const fn chh(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Channel halted"]
|
|
#[inline(always)]
|
|
pub fn set_chh(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "STALL response received interrupt"]
|
|
#[inline(always)]
|
|
pub const fn stall(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "STALL response received interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_stall(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "NAK response received interrupt"]
|
|
#[inline(always)]
|
|
pub const fn nak(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "NAK response received interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_nak(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "ACK response received/transmitted interrupt"]
|
|
#[inline(always)]
|
|
pub const fn ack(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ACK response received/transmitted interrupt"]
|
|
#[inline(always)]
|
|
pub fn set_ack(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "Transaction error"]
|
|
#[inline(always)]
|
|
pub const fn txerr(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transaction error"]
|
|
#[inline(always)]
|
|
pub fn set_txerr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Babble error"]
|
|
#[inline(always)]
|
|
pub const fn bberr(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Babble error"]
|
|
#[inline(always)]
|
|
pub fn set_bberr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "Frame overrun"]
|
|
#[inline(always)]
|
|
pub const fn frmor(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Frame overrun"]
|
|
#[inline(always)]
|
|
pub fn set_frmor(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "Data toggle error"]
|
|
#[inline(always)]
|
|
pub const fn dterr(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data toggle error"]
|
|
#[inline(always)]
|
|
pub fn set_dterr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
}
|
|
impl Default for Hcint {
|
|
#[inline(always)]
|
|
fn default() -> Hcint {
|
|
Hcint(0)
|
|
}
|
|
}
|
|
#[doc = "Host channel mask register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hcintmsk(pub u32);
|
|
impl Hcintmsk {
|
|
#[doc = "Transfer completed mask"]
|
|
#[inline(always)]
|
|
pub const fn xfrcm(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transfer completed mask"]
|
|
#[inline(always)]
|
|
pub fn set_xfrcm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Channel halted mask"]
|
|
#[inline(always)]
|
|
pub const fn chhm(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Channel halted mask"]
|
|
#[inline(always)]
|
|
pub fn set_chhm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "STALL response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn stallm(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "STALL response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_stallm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "NAK response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn nakm(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "NAK response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_nakm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "ACK response received/transmitted interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn ackm(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "ACK response received/transmitted interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_ackm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "Response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub const fn nyet(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Response received interrupt mask"]
|
|
#[inline(always)]
|
|
pub fn set_nyet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "Transaction error mask"]
|
|
#[inline(always)]
|
|
pub const fn txerrm(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Transaction error mask"]
|
|
#[inline(always)]
|
|
pub fn set_txerrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Babble error mask"]
|
|
#[inline(always)]
|
|
pub const fn bberrm(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Babble error mask"]
|
|
#[inline(always)]
|
|
pub fn set_bberrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "Frame overrun mask"]
|
|
#[inline(always)]
|
|
pub const fn frmorm(&self) -> bool {
|
|
let val = (self.0 >> 9usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Frame overrun mask"]
|
|
#[inline(always)]
|
|
pub fn set_frmorm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
|
|
}
|
|
#[doc = "Data toggle error mask"]
|
|
#[inline(always)]
|
|
pub const fn dterrm(&self) -> bool {
|
|
let val = (self.0 >> 10usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Data toggle error mask"]
|
|
#[inline(always)]
|
|
pub fn set_dterrm(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
|
|
}
|
|
}
|
|
impl Default for Hcintmsk {
|
|
#[inline(always)]
|
|
fn default() -> Hcintmsk {
|
|
Hcintmsk(0)
|
|
}
|
|
}
|
|
#[doc = "Host channel transfer size register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hctsiz(pub u32);
|
|
impl Hctsiz {
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub const fn xfrsiz(&self) -> u32 {
|
|
let val = (self.0 >> 0usize) & 0x0007_ffff;
|
|
val as u32
|
|
}
|
|
#[doc = "Transfer size"]
|
|
#[inline(always)]
|
|
pub fn set_xfrsiz(&mut self, val: u32) {
|
|
self.0 = (self.0 & !(0x0007_ffff << 0usize)) | (((val as u32) & 0x0007_ffff) << 0usize);
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub const fn pktcnt(&self) -> u16 {
|
|
let val = (self.0 >> 19usize) & 0x03ff;
|
|
val as u16
|
|
}
|
|
#[doc = "Packet count"]
|
|
#[inline(always)]
|
|
pub fn set_pktcnt(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0x03ff << 19usize)) | (((val as u32) & 0x03ff) << 19usize);
|
|
}
|
|
#[doc = "Data PID"]
|
|
#[inline(always)]
|
|
pub const fn dpid(&self) -> u8 {
|
|
let val = (self.0 >> 29usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Data PID"]
|
|
#[inline(always)]
|
|
pub fn set_dpid(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 29usize)) | (((val as u32) & 0x03) << 29usize);
|
|
}
|
|
}
|
|
impl Default for Hctsiz {
|
|
#[inline(always)]
|
|
fn default() -> Hctsiz {
|
|
Hctsiz(0)
|
|
}
|
|
}
|
|
#[doc = "Host frame interval register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hfir(pub u32);
|
|
impl Hfir {
|
|
#[doc = "Frame interval"]
|
|
#[inline(always)]
|
|
pub const fn frivl(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Frame interval"]
|
|
#[inline(always)]
|
|
pub fn set_frivl(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
}
|
|
impl Default for Hfir {
|
|
#[inline(always)]
|
|
fn default() -> Hfir {
|
|
Hfir(0)
|
|
}
|
|
}
|
|
#[doc = "Host frame number/frame time remaining register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hfnum(pub u32);
|
|
impl Hfnum {
|
|
#[doc = "Frame number"]
|
|
#[inline(always)]
|
|
pub const fn frnum(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Frame number"]
|
|
#[inline(always)]
|
|
pub fn set_frnum(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "Frame time remaining"]
|
|
#[inline(always)]
|
|
pub const fn ftrem(&self) -> u16 {
|
|
let val = (self.0 >> 16usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Frame time remaining"]
|
|
#[inline(always)]
|
|
pub fn set_ftrem(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
|
|
}
|
|
}
|
|
impl Default for Hfnum {
|
|
#[inline(always)]
|
|
fn default() -> Hfnum {
|
|
Hfnum(0)
|
|
}
|
|
}
|
|
#[doc = "Non-periodic transmit FIFO/queue status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hnptxsts(pub u32);
|
|
impl Hnptxsts {
|
|
#[doc = "Non-periodic TxFIFO space available"]
|
|
#[inline(always)]
|
|
pub const fn nptxfsav(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Non-periodic TxFIFO space available"]
|
|
#[inline(always)]
|
|
pub fn set_nptxfsav(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "Non-periodic transmit request queue space available"]
|
|
#[inline(always)]
|
|
pub const fn nptqxsav(&self) -> u8 {
|
|
let val = (self.0 >> 16usize) & 0xff;
|
|
val as u8
|
|
}
|
|
#[doc = "Non-periodic transmit request queue space available"]
|
|
#[inline(always)]
|
|
pub fn set_nptqxsav(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
|
|
}
|
|
#[doc = "Top of the non-periodic transmit request queue"]
|
|
#[inline(always)]
|
|
pub const fn nptxqtop(&self) -> u8 {
|
|
let val = (self.0 >> 24usize) & 0x7f;
|
|
val as u8
|
|
}
|
|
#[doc = "Top of the non-periodic transmit request queue"]
|
|
#[inline(always)]
|
|
pub fn set_nptxqtop(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x7f << 24usize)) | (((val as u32) & 0x7f) << 24usize);
|
|
}
|
|
}
|
|
impl Default for Hnptxsts {
|
|
#[inline(always)]
|
|
fn default() -> Hnptxsts {
|
|
Hnptxsts(0)
|
|
}
|
|
}
|
|
#[doc = "Host port control and status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hprt(pub u32);
|
|
impl Hprt {
|
|
#[doc = "Port connect status"]
|
|
#[inline(always)]
|
|
pub const fn pcsts(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port connect status"]
|
|
#[inline(always)]
|
|
pub fn set_pcsts(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Port connect detected"]
|
|
#[inline(always)]
|
|
pub const fn pcdet(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port connect detected"]
|
|
#[inline(always)]
|
|
pub fn set_pcdet(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "Port enable"]
|
|
#[inline(always)]
|
|
pub const fn pena(&self) -> bool {
|
|
let val = (self.0 >> 2usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port enable"]
|
|
#[inline(always)]
|
|
pub fn set_pena(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
|
|
}
|
|
#[doc = "Port enable/disable change"]
|
|
#[inline(always)]
|
|
pub const fn penchng(&self) -> bool {
|
|
let val = (self.0 >> 3usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port enable/disable change"]
|
|
#[inline(always)]
|
|
pub fn set_penchng(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
|
|
}
|
|
#[doc = "Port overcurrent active"]
|
|
#[inline(always)]
|
|
pub const fn poca(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port overcurrent active"]
|
|
#[inline(always)]
|
|
pub fn set_poca(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
#[doc = "Port overcurrent change"]
|
|
#[inline(always)]
|
|
pub const fn pocchng(&self) -> bool {
|
|
let val = (self.0 >> 5usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port overcurrent change"]
|
|
#[inline(always)]
|
|
pub fn set_pocchng(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
|
|
}
|
|
#[doc = "Port resume"]
|
|
#[inline(always)]
|
|
pub const fn pres(&self) -> bool {
|
|
let val = (self.0 >> 6usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port resume"]
|
|
#[inline(always)]
|
|
pub fn set_pres(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
|
|
}
|
|
#[doc = "Port suspend"]
|
|
#[inline(always)]
|
|
pub const fn psusp(&self) -> bool {
|
|
let val = (self.0 >> 7usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port suspend"]
|
|
#[inline(always)]
|
|
pub fn set_psusp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
|
|
}
|
|
#[doc = "Port reset"]
|
|
#[inline(always)]
|
|
pub const fn prst(&self) -> bool {
|
|
let val = (self.0 >> 8usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port reset"]
|
|
#[inline(always)]
|
|
pub fn set_prst(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
|
|
}
|
|
#[doc = "Port line status"]
|
|
#[inline(always)]
|
|
pub const fn plsts(&self) -> u8 {
|
|
let val = (self.0 >> 10usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Port line status"]
|
|
#[inline(always)]
|
|
pub fn set_plsts(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 10usize)) | (((val as u32) & 0x03) << 10usize);
|
|
}
|
|
#[doc = "Port power"]
|
|
#[inline(always)]
|
|
pub const fn ppwr(&self) -> bool {
|
|
let val = (self.0 >> 12usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Port power"]
|
|
#[inline(always)]
|
|
pub fn set_ppwr(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
|
|
}
|
|
#[doc = "Port test control"]
|
|
#[inline(always)]
|
|
pub const fn ptctl(&self) -> u8 {
|
|
let val = (self.0 >> 13usize) & 0x0f;
|
|
val as u8
|
|
}
|
|
#[doc = "Port test control"]
|
|
#[inline(always)]
|
|
pub fn set_ptctl(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x0f << 13usize)) | (((val as u32) & 0x0f) << 13usize);
|
|
}
|
|
#[doc = "Port speed"]
|
|
#[inline(always)]
|
|
pub const fn pspd(&self) -> u8 {
|
|
let val = (self.0 >> 17usize) & 0x03;
|
|
val as u8
|
|
}
|
|
#[doc = "Port speed"]
|
|
#[inline(always)]
|
|
pub fn set_pspd(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0x03 << 17usize)) | (((val as u32) & 0x03) << 17usize);
|
|
}
|
|
}
|
|
impl Default for Hprt {
|
|
#[inline(always)]
|
|
fn default() -> Hprt {
|
|
Hprt(0)
|
|
}
|
|
}
|
|
#[doc = "Periodic transmit FIFO/queue status register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Hptxsts(pub u32);
|
|
impl Hptxsts {
|
|
#[doc = "Periodic transmit data FIFO space available"]
|
|
#[inline(always)]
|
|
pub const fn ptxfsavl(&self) -> u16 {
|
|
let val = (self.0 >> 0usize) & 0xffff;
|
|
val as u16
|
|
}
|
|
#[doc = "Periodic transmit data FIFO space available"]
|
|
#[inline(always)]
|
|
pub fn set_ptxfsavl(&mut self, val: u16) {
|
|
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
|
|
}
|
|
#[doc = "Periodic transmit request queue space available"]
|
|
#[inline(always)]
|
|
pub const fn ptxqsav(&self) -> u8 {
|
|
let val = (self.0 >> 16usize) & 0xff;
|
|
val as u8
|
|
}
|
|
#[doc = "Periodic transmit request queue space available"]
|
|
#[inline(always)]
|
|
pub fn set_ptxqsav(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
|
|
}
|
|
#[doc = "Top of the periodic transmit request queue"]
|
|
#[inline(always)]
|
|
pub const fn ptxqtop(&self) -> u8 {
|
|
let val = (self.0 >> 24usize) & 0xff;
|
|
val as u8
|
|
}
|
|
#[doc = "Top of the periodic transmit request queue"]
|
|
#[inline(always)]
|
|
pub fn set_ptxqtop(&mut self, val: u8) {
|
|
self.0 = (self.0 & !(0xff << 24usize)) | (((val as u32) & 0xff) << 24usize);
|
|
}
|
|
}
|
|
impl Default for Hptxsts {
|
|
#[inline(always)]
|
|
fn default() -> Hptxsts {
|
|
Hptxsts(0)
|
|
}
|
|
}
|
|
#[doc = "Power and clock gating control register"]
|
|
#[repr(transparent)]
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct Pcgcctl(pub u32);
|
|
impl Pcgcctl {
|
|
#[doc = "Stop PHY clock"]
|
|
#[inline(always)]
|
|
pub const fn stppclk(&self) -> bool {
|
|
let val = (self.0 >> 0usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Stop PHY clock"]
|
|
#[inline(always)]
|
|
pub fn set_stppclk(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
|
|
}
|
|
#[doc = "Gate HCLK"]
|
|
#[inline(always)]
|
|
pub const fn gatehclk(&self) -> bool {
|
|
let val = (self.0 >> 1usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "Gate HCLK"]
|
|
#[inline(always)]
|
|
pub fn set_gatehclk(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
|
|
}
|
|
#[doc = "PHY Suspended"]
|
|
#[inline(always)]
|
|
pub const fn physusp(&self) -> bool {
|
|
let val = (self.0 >> 4usize) & 0x01;
|
|
val != 0
|
|
}
|
|
#[doc = "PHY Suspended"]
|
|
#[inline(always)]
|
|
pub fn set_physusp(&mut self, val: bool) {
|
|
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
|
|
}
|
|
}
|
|
impl Default for Pcgcctl {
|
|
#[inline(always)]
|
|
fn default() -> Pcgcctl {
|
|
Pcgcctl(0)
|
|
}
|
|
}
|
|
}
|
|
pub mod vals {
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Dpid {
|
|
DATA0 = 0x0,
|
|
DATA2 = 0x01,
|
|
DATA1 = 0x02,
|
|
MDATA = 0x03,
|
|
}
|
|
impl Dpid {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Dpid {
|
|
unsafe { core::mem::transmute(val & 0x03) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Dpid {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Dpid {
|
|
Dpid::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Dpid> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Dpid) -> u8 {
|
|
Dpid::to_bits(val)
|
|
}
|
|
}
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Dspd {
|
|
#[doc = "High speed"]
|
|
HIGH_SPEED = 0x0,
|
|
#[doc = "Full speed using external ULPI PHY"]
|
|
FULL_SPEED_EXTERNAL = 0x01,
|
|
_RESERVED_2 = 0x02,
|
|
#[doc = "Full speed using internal embedded PHY"]
|
|
FULL_SPEED_INTERNAL = 0x03,
|
|
}
|
|
impl Dspd {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Dspd {
|
|
unsafe { core::mem::transmute(val & 0x03) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Dspd {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Dspd {
|
|
Dspd::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Dspd> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Dspd) -> u8 {
|
|
Dspd::to_bits(val)
|
|
}
|
|
}
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Eptyp {
|
|
CONTROL = 0x0,
|
|
ISOCHRONOUS = 0x01,
|
|
BULK = 0x02,
|
|
INTERRUPT = 0x03,
|
|
}
|
|
impl Eptyp {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Eptyp {
|
|
unsafe { core::mem::transmute(val & 0x03) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Eptyp {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Eptyp {
|
|
Eptyp::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Eptyp> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Eptyp) -> u8 {
|
|
Eptyp::to_bits(val)
|
|
}
|
|
}
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Pfivl {
|
|
#[doc = "80% of the frame interval"]
|
|
FRAME_INTERVAL_80 = 0x0,
|
|
#[doc = "85% of the frame interval"]
|
|
FRAME_INTERVAL_85 = 0x01,
|
|
#[doc = "90% of the frame interval"]
|
|
FRAME_INTERVAL_90 = 0x02,
|
|
#[doc = "95% of the frame interval"]
|
|
FRAME_INTERVAL_95 = 0x03,
|
|
}
|
|
impl Pfivl {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Pfivl {
|
|
unsafe { core::mem::transmute(val & 0x03) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Pfivl {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Pfivl {
|
|
Pfivl::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Pfivl> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Pfivl) -> u8 {
|
|
Pfivl::to_bits(val)
|
|
}
|
|
}
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Pktstsd {
|
|
_RESERVED_0 = 0x0,
|
|
#[doc = "Global OUT NAK (triggers an interrupt)"]
|
|
OUT_NAK = 0x01,
|
|
#[doc = "OUT data packet received"]
|
|
OUT_DATA_RX = 0x02,
|
|
#[doc = "OUT transfer completed (triggers an interrupt)"]
|
|
OUT_DATA_DONE = 0x03,
|
|
#[doc = "SETUP transaction completed (triggers an interrupt)"]
|
|
SETUP_DATA_DONE = 0x04,
|
|
_RESERVED_5 = 0x05,
|
|
#[doc = "SETUP data packet received"]
|
|
SETUP_DATA_RX = 0x06,
|
|
_RESERVED_7 = 0x07,
|
|
_RESERVED_8 = 0x08,
|
|
_RESERVED_9 = 0x09,
|
|
_RESERVED_a = 0x0a,
|
|
_RESERVED_b = 0x0b,
|
|
_RESERVED_c = 0x0c,
|
|
_RESERVED_d = 0x0d,
|
|
_RESERVED_e = 0x0e,
|
|
_RESERVED_f = 0x0f,
|
|
}
|
|
impl Pktstsd {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Pktstsd {
|
|
unsafe { core::mem::transmute(val & 0x0f) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Pktstsd {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Pktstsd {
|
|
Pktstsd::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Pktstsd> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Pktstsd) -> u8 {
|
|
Pktstsd::to_bits(val)
|
|
}
|
|
}
|
|
#[repr(u8)]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Pktstsh {
|
|
_RESERVED_0 = 0x0,
|
|
_RESERVED_1 = 0x01,
|
|
#[doc = "IN data packet received"]
|
|
IN_DATA_RX = 0x02,
|
|
#[doc = "IN transfer completed (triggers an interrupt)"]
|
|
IN_DATA_DONE = 0x03,
|
|
_RESERVED_4 = 0x04,
|
|
#[doc = "Data toggle error (triggers an interrupt)"]
|
|
DATA_TOGGLE_ERR = 0x05,
|
|
_RESERVED_6 = 0x06,
|
|
#[doc = "Channel halted (triggers an interrupt)"]
|
|
CHANNEL_HALTED = 0x07,
|
|
_RESERVED_8 = 0x08,
|
|
_RESERVED_9 = 0x09,
|
|
_RESERVED_a = 0x0a,
|
|
_RESERVED_b = 0x0b,
|
|
_RESERVED_c = 0x0c,
|
|
_RESERVED_d = 0x0d,
|
|
_RESERVED_e = 0x0e,
|
|
_RESERVED_f = 0x0f,
|
|
}
|
|
impl Pktstsh {
|
|
#[inline(always)]
|
|
pub const fn from_bits(val: u8) -> Pktstsh {
|
|
unsafe { core::mem::transmute(val & 0x0f) }
|
|
}
|
|
#[inline(always)]
|
|
pub const fn to_bits(self) -> u8 {
|
|
unsafe { core::mem::transmute(self) }
|
|
}
|
|
}
|
|
impl From<u8> for Pktstsh {
|
|
#[inline(always)]
|
|
fn from(val: u8) -> Pktstsh {
|
|
Pktstsh::from_bits(val)
|
|
}
|
|
}
|
|
impl From<Pktstsh> for u8 {
|
|
#[inline(always)]
|
|
fn from(val: Pktstsh) -> u8 {
|
|
Pktstsh::to_bits(val)
|
|
}
|
|
}
|
|
}
|