feat: add display UI with splash screen, dashboard, and RSSI sparkline

Implement full SSD1306 OLED display support:
- Splash screen on boot (1.5s) with project name, version, board
- Dashboard showing radio state, config, counters, RSSI/SNR
- RSSI history sparkline (64-sample ring buffer, 2px-wide bars)
- DisplayOn/DisplayOff host commands routed via dedicated channel
- Pure render functions against generic DrawTarget (no hardware coupling)
- Display on/off control bypasses radio task entirely

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

vendor/nrf5340-app-pac/src/usbregulator_ns/events_usbdetected.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_USBDETECTED` reader"]
+pub struct R(crate::R<EVENTS_USBDETECTED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_USBDETECTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_USBDETECTED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_USBDETECTED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_USBDETECTED` writer"]
+pub struct W(crate::W<EVENTS_USBDETECTED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_USBDETECTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<EVENTS_USBDETECTED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_USBDETECTED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_USBDETECTED` reader - Voltage supply detected on VBUS"]
+pub type EVENTS_USBDETECTED_R = crate::BitReader<EVENTS_USBDETECTED_A>;
+#[doc = "Voltage supply detected on VBUS\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_USBDETECTED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_USBDETECTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_USBDETECTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_USBDETECTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_USBDETECTED_A {
+        match self.bits {
+            false => EVENTS_USBDETECTED_A::NOT_GENERATED,
+            true => EVENTS_USBDETECTED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_USBDETECTED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_USBDETECTED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_USBDETECTED` writer - Voltage supply detected on VBUS"]
+pub type EVENTS_USBDETECTED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_USBDETECTED_SPEC, EVENTS_USBDETECTED_A, O>;
+impl<'a, const O: u8> EVENTS_USBDETECTED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBDETECTED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBDETECTED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Voltage supply detected on VBUS"]
+    #[inline(always)]
+    pub fn events_usbdetected(&self) -> EVENTS_USBDETECTED_R {
+        EVENTS_USBDETECTED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Voltage supply detected on VBUS"]
+    #[inline(always)]
+    pub fn events_usbdetected(&mut self) -> EVENTS_USBDETECTED_W<0> {
+        EVENTS_USBDETECTED_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Voltage supply detected on VBUS\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [events_usbdetected](index.html) module"]
+pub struct EVENTS_USBDETECTED_SPEC;
+impl crate::RegisterSpec for EVENTS_USBDETECTED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_usbdetected::R](R) reader structure"]
+impl crate::Readable for EVENTS_USBDETECTED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_usbdetected::W](W) writer structure"]
+impl crate::Writable for EVENTS_USBDETECTED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_USBDETECTED to value 0"]
+impl crate::Resettable for EVENTS_USBDETECTED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/events_usbpwrrdy.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_USBPWRRDY` reader"]
+pub struct R(crate::R<EVENTS_USBPWRRDY_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_USBPWRRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_USBPWRRDY_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_USBPWRRDY_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_USBPWRRDY` writer"]
+pub struct W(crate::W<EVENTS_USBPWRRDY_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_USBPWRRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<EVENTS_USBPWRRDY_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_USBPWRRDY_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_USBPWRRDY` reader - USB 3.3 V supply ready"]
+pub type EVENTS_USBPWRRDY_R = crate::BitReader<EVENTS_USBPWRRDY_A>;
+#[doc = "USB 3.3 V supply ready\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_USBPWRRDY_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_USBPWRRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_USBPWRRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_USBPWRRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_USBPWRRDY_A {
+        match self.bits {
+            false => EVENTS_USBPWRRDY_A::NOT_GENERATED,
+            true => EVENTS_USBPWRRDY_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_USBPWRRDY_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_USBPWRRDY_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_USBPWRRDY` writer - USB 3.3 V supply ready"]
+pub type EVENTS_USBPWRRDY_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_USBPWRRDY_SPEC, EVENTS_USBPWRRDY_A, O>;
+impl<'a, const O: u8> EVENTS_USBPWRRDY_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBPWRRDY_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBPWRRDY_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - USB 3.3 V supply ready"]
+    #[inline(always)]
+    pub fn events_usbpwrrdy(&self) -> EVENTS_USBPWRRDY_R {
+        EVENTS_USBPWRRDY_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - USB 3.3 V supply ready"]
+    #[inline(always)]
+    pub fn events_usbpwrrdy(&mut self) -> EVENTS_USBPWRRDY_W<0> {
+        EVENTS_USBPWRRDY_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "USB 3.3 V supply ready\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [events_usbpwrrdy](index.html) module"]
+pub struct EVENTS_USBPWRRDY_SPEC;
+impl crate::RegisterSpec for EVENTS_USBPWRRDY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_usbpwrrdy::R](R) reader structure"]
+impl crate::Readable for EVENTS_USBPWRRDY_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_usbpwrrdy::W](W) writer structure"]
+impl crate::Writable for EVENTS_USBPWRRDY_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_USBPWRRDY to value 0"]
+impl crate::Resettable for EVENTS_USBPWRRDY_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/events_usbremoved.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_USBREMOVED` reader"]
+pub struct R(crate::R<EVENTS_USBREMOVED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_USBREMOVED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_USBREMOVED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_USBREMOVED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_USBREMOVED` writer"]
+pub struct W(crate::W<EVENTS_USBREMOVED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_USBREMOVED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<EVENTS_USBREMOVED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_USBREMOVED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_USBREMOVED` reader - Voltage supply removed from VBUS"]
+pub type EVENTS_USBREMOVED_R = crate::BitReader<EVENTS_USBREMOVED_A>;
+#[doc = "Voltage supply removed from VBUS\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_USBREMOVED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_USBREMOVED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_USBREMOVED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_USBREMOVED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_USBREMOVED_A {
+        match self.bits {
+            false => EVENTS_USBREMOVED_A::NOT_GENERATED,
+            true => EVENTS_USBREMOVED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_USBREMOVED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_USBREMOVED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_USBREMOVED` writer - Voltage supply removed from VBUS"]
+pub type EVENTS_USBREMOVED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_USBREMOVED_SPEC, EVENTS_USBREMOVED_A, O>;
+impl<'a, const O: u8> EVENTS_USBREMOVED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBREMOVED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_USBREMOVED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Voltage supply removed from VBUS"]
+    #[inline(always)]
+    pub fn events_usbremoved(&self) -> EVENTS_USBREMOVED_R {
+        EVENTS_USBREMOVED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Voltage supply removed from VBUS"]
+    #[inline(always)]
+    pub fn events_usbremoved(&mut self) -> EVENTS_USBREMOVED_W<0> {
+        EVENTS_USBREMOVED_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Voltage supply removed from VBUS\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [events_usbremoved](index.html) module"]
+pub struct EVENTS_USBREMOVED_SPEC;
+impl crate::RegisterSpec for EVENTS_USBREMOVED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_usbremoved::R](R) reader structure"]
+impl crate::Readable for EVENTS_USBREMOVED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_usbremoved::W](W) writer structure"]
+impl crate::Writable for EVENTS_USBREMOVED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_USBREMOVED to value 0"]
+impl crate::Resettable for EVENTS_USBREMOVED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/inten.rs

@@ -0,0 +1,246 @@
+#[doc = "Register `INTEN` reader"]
+pub struct R(crate::R<INTEN_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTEN_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTEN_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTEN_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTEN` writer"]
+pub struct W(crate::W<INTEN_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTEN_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INTEN_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTEN_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `USBDETECTED` reader - Enable or disable interrupt for event USBDETECTED"]
+pub type USBDETECTED_R = crate::BitReader<USBDETECTED_A>;
+#[doc = "Enable or disable interrupt for event USBDETECTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBDETECTED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<USBDETECTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBDETECTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBDETECTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBDETECTED_A {
+        match self.bits {
+            false => USBDETECTED_A::DISABLED,
+            true => USBDETECTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBDETECTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBDETECTED_A::ENABLED
+    }
+}
+#[doc = "Field `USBDETECTED` writer - Enable or disable interrupt for event USBDETECTED"]
+pub type USBDETECTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, USBDETECTED_A, O>;
+impl<'a, const O: u8> USBDETECTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(USBDETECTED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(USBDETECTED_A::ENABLED)
+    }
+}
+#[doc = "Field `USBREMOVED` reader - Enable or disable interrupt for event USBREMOVED"]
+pub type USBREMOVED_R = crate::BitReader<USBREMOVED_A>;
+#[doc = "Enable or disable interrupt for event USBREMOVED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBREMOVED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<USBREMOVED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBREMOVED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBREMOVED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBREMOVED_A {
+        match self.bits {
+            false => USBREMOVED_A::DISABLED,
+            true => USBREMOVED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBREMOVED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBREMOVED_A::ENABLED
+    }
+}
+#[doc = "Field `USBREMOVED` writer - Enable or disable interrupt for event USBREMOVED"]
+pub type USBREMOVED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, USBREMOVED_A, O>;
+impl<'a, const O: u8> USBREMOVED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(USBREMOVED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(USBREMOVED_A::ENABLED)
+    }
+}
+#[doc = "Field `USBPWRRDY` reader - Enable or disable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_R = crate::BitReader<USBPWRRDY_A>;
+#[doc = "Enable or disable interrupt for event USBPWRRDY\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBPWRRDY_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<USBPWRRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBPWRRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBPWRRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBPWRRDY_A {
+        match self.bits {
+            false => USBPWRRDY_A::DISABLED,
+            true => USBPWRRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBPWRRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBPWRRDY_A::ENABLED
+    }
+}
+#[doc = "Field `USBPWRRDY` writer - Enable or disable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, USBPWRRDY_A, O>;
+impl<'a, const O: u8> USBPWRRDY_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(USBPWRRDY_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(USBPWRRDY_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Enable or disable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&self) -> USBDETECTED_R {
+        USBDETECTED_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Enable or disable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&self) -> USBREMOVED_R {
+        USBREMOVED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Enable or disable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&self) -> USBPWRRDY_R {
+        USBPWRRDY_R::new(((self.bits >> 2) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Enable or disable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&mut self) -> USBDETECTED_W<0> {
+        USBDETECTED_W::new(self)
+    }
+    #[doc = "Bit 1 - Enable or disable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&mut self) -> USBREMOVED_W<1> {
+        USBREMOVED_W::new(self)
+    }
+    #[doc = "Bit 2 - Enable or disable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&mut self) -> USBPWRRDY_W<2> {
+        USBPWRRDY_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Enable or disable interrupt\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [inten](index.html) module"]
+pub struct INTEN_SPEC;
+impl crate::RegisterSpec for INTEN_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [inten::R](R) reader structure"]
+impl crate::Readable for INTEN_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [inten::W](W) writer structure"]
+impl crate::Writable for INTEN_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTEN to value 0"]
+impl crate::Resettable for INTEN_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/intenclr.rs

@@ -0,0 +1,268 @@
+#[doc = "Register `INTENCLR` reader"]
+pub struct R(crate::R<INTENCLR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTENCLR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTENCLR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTENCLR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTENCLR` writer"]
+pub struct W(crate::W<INTENCLR_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTENCLR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INTENCLR_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTENCLR_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `USBDETECTED` reader - Write '1' to disable interrupt for event USBDETECTED"]
+pub type USBDETECTED_R = crate::BitReader<USBDETECTED_A>;
+#[doc = "Write '1' to disable interrupt for event USBDETECTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBDETECTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBDETECTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBDETECTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBDETECTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBDETECTED_A {
+        match self.bits {
+            false => USBDETECTED_A::DISABLED,
+            true => USBDETECTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBDETECTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBDETECTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event USBDETECTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBDETECTED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<USBDETECTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBDETECTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBDETECTED` writer - Write '1' to disable interrupt for event USBDETECTED"]
+pub type USBDETECTED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, INTENCLR_SPEC, USBDETECTED_AW, O>;
+impl<'a, const O: u8> USBDETECTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(USBDETECTED_AW::CLEAR)
+    }
+}
+#[doc = "Field `USBREMOVED` reader - Write '1' to disable interrupt for event USBREMOVED"]
+pub type USBREMOVED_R = crate::BitReader<USBREMOVED_A>;
+#[doc = "Write '1' to disable interrupt for event USBREMOVED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBREMOVED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBREMOVED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBREMOVED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBREMOVED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBREMOVED_A {
+        match self.bits {
+            false => USBREMOVED_A::DISABLED,
+            true => USBREMOVED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBREMOVED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBREMOVED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event USBREMOVED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBREMOVED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<USBREMOVED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBREMOVED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBREMOVED` writer - Write '1' to disable interrupt for event USBREMOVED"]
+pub type USBREMOVED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, USBREMOVED_AW, O>;
+impl<'a, const O: u8> USBREMOVED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(USBREMOVED_AW::CLEAR)
+    }
+}
+#[doc = "Field `USBPWRRDY` reader - Write '1' to disable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_R = crate::BitReader<USBPWRRDY_A>;
+#[doc = "Write '1' to disable interrupt for event USBPWRRDY\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBPWRRDY_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBPWRRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBPWRRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBPWRRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBPWRRDY_A {
+        match self.bits {
+            false => USBPWRRDY_A::DISABLED,
+            true => USBPWRRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBPWRRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBPWRRDY_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event USBPWRRDY\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBPWRRDY_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<USBPWRRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBPWRRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBPWRRDY` writer - Write '1' to disable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, USBPWRRDY_AW, O>;
+impl<'a, const O: u8> USBPWRRDY_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(USBPWRRDY_AW::CLEAR)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Write '1' to disable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&self) -> USBDETECTED_R {
+        USBDETECTED_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Write '1' to disable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&self) -> USBREMOVED_R {
+        USBREMOVED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Write '1' to disable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&self) -> USBPWRRDY_R {
+        USBPWRRDY_R::new(((self.bits >> 2) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Write '1' to disable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&mut self) -> USBDETECTED_W<0> {
+        USBDETECTED_W::new(self)
+    }
+    #[doc = "Bit 1 - Write '1' to disable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&mut self) -> USBREMOVED_W<1> {
+        USBREMOVED_W::new(self)
+    }
+    #[doc = "Bit 2 - Write '1' to disable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&mut self) -> USBPWRRDY_W<2> {
+        USBPWRRDY_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Disable interrupt\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [intenclr](index.html) module"]
+pub struct INTENCLR_SPEC;
+impl crate::RegisterSpec for INTENCLR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [intenclr::R](R) reader structure"]
+impl crate::Readable for INTENCLR_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [intenclr::W](W) writer structure"]
+impl crate::Writable for INTENCLR_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTENCLR to value 0"]
+impl crate::Resettable for INTENCLR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/intenset.rs

@@ -0,0 +1,268 @@
+#[doc = "Register `INTENSET` reader"]
+pub struct R(crate::R<INTENSET_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTENSET_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTENSET_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTENSET` writer"]
+pub struct W(crate::W<INTENSET_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTENSET_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INTENSET_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `USBDETECTED` reader - Write '1' to enable interrupt for event USBDETECTED"]
+pub type USBDETECTED_R = crate::BitReader<USBDETECTED_A>;
+#[doc = "Write '1' to enable interrupt for event USBDETECTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBDETECTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBDETECTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBDETECTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBDETECTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBDETECTED_A {
+        match self.bits {
+            false => USBDETECTED_A::DISABLED,
+            true => USBDETECTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBDETECTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBDETECTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event USBDETECTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBDETECTED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<USBDETECTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBDETECTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBDETECTED` writer - Write '1' to enable interrupt for event USBDETECTED"]
+pub type USBDETECTED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, INTENSET_SPEC, USBDETECTED_AW, O>;
+impl<'a, const O: u8> USBDETECTED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(USBDETECTED_AW::SET)
+    }
+}
+#[doc = "Field `USBREMOVED` reader - Write '1' to enable interrupt for event USBREMOVED"]
+pub type USBREMOVED_R = crate::BitReader<USBREMOVED_A>;
+#[doc = "Write '1' to enable interrupt for event USBREMOVED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBREMOVED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBREMOVED_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBREMOVED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBREMOVED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBREMOVED_A {
+        match self.bits {
+            false => USBREMOVED_A::DISABLED,
+            true => USBREMOVED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBREMOVED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBREMOVED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event USBREMOVED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBREMOVED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<USBREMOVED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBREMOVED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBREMOVED` writer - Write '1' to enable interrupt for event USBREMOVED"]
+pub type USBREMOVED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, USBREMOVED_AW, O>;
+impl<'a, const O: u8> USBREMOVED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(USBREMOVED_AW::SET)
+    }
+}
+#[doc = "Field `USBPWRRDY` reader - Write '1' to enable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_R = crate::BitReader<USBPWRRDY_A>;
+#[doc = "Write '1' to enable interrupt for event USBPWRRDY\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBPWRRDY_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<USBPWRRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: USBPWRRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl USBPWRRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> USBPWRRDY_A {
+        match self.bits {
+            false => USBPWRRDY_A::DISABLED,
+            true => USBPWRRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == USBPWRRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == USBPWRRDY_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event USBPWRRDY\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum USBPWRRDY_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<USBPWRRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: USBPWRRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `USBPWRRDY` writer - Write '1' to enable interrupt for event USBPWRRDY"]
+pub type USBPWRRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, USBPWRRDY_AW, O>;
+impl<'a, const O: u8> USBPWRRDY_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(USBPWRRDY_AW::SET)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Write '1' to enable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&self) -> USBDETECTED_R {
+        USBDETECTED_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Write '1' to enable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&self) -> USBREMOVED_R {
+        USBREMOVED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Write '1' to enable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&self) -> USBPWRRDY_R {
+        USBPWRRDY_R::new(((self.bits >> 2) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Write '1' to enable interrupt for event USBDETECTED"]
+    #[inline(always)]
+    pub fn usbdetected(&mut self) -> USBDETECTED_W<0> {
+        USBDETECTED_W::new(self)
+    }
+    #[doc = "Bit 1 - Write '1' to enable interrupt for event USBREMOVED"]
+    #[inline(always)]
+    pub fn usbremoved(&mut self) -> USBREMOVED_W<1> {
+        USBREMOVED_W::new(self)
+    }
+    #[doc = "Bit 2 - Write '1' to enable interrupt for event USBPWRRDY"]
+    #[inline(always)]
+    pub fn usbpwrrdy(&mut self) -> USBPWRRDY_W<2> {
+        USBPWRRDY_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Enable interrupt\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [intenset](index.html) module"]
+pub struct INTENSET_SPEC;
+impl crate::RegisterSpec for INTENSET_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [intenset::R](R) reader structure"]
+impl crate::Readable for INTENSET_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [intenset::W](W) writer structure"]
+impl crate::Writable for INTENSET_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTENSET to value 0"]
+impl crate::Resettable for INTENSET_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/publish_usbdetected.rs

@@ -0,0 +1,141 @@
+#[doc = "Register `PUBLISH_USBDETECTED` reader"]
+pub struct R(crate::R<PUBLISH_USBDETECTED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PUBLISH_USBDETECTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PUBLISH_USBDETECTED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PUBLISH_USBDETECTED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PUBLISH_USBDETECTED` writer"]
+pub struct W(crate::W<PUBLISH_USBDETECTED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PUBLISH_USBDETECTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<PUBLISH_USBDETECTED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PUBLISH_USBDETECTED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CHIDX` reader - DPPI channel that event USBDETECTED will publish to."]
+pub type CHIDX_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `CHIDX` writer - DPPI channel that event USBDETECTED will publish to."]
+pub type CHIDX_W<'a, const O: u8> =
+    crate::FieldWriter<'a, u32, PUBLISH_USBDETECTED_SPEC, u8, u8, 8, O>;
+#[doc = "Field `EN` reader - "]
+pub type EN_R = crate::BitReader<EN_A>;
+#[doc = "\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EN_A {
+    #[doc = "0: Disable publishing"]
+    DISABLED = 0,
+    #[doc = "1: Enable publishing"]
+    ENABLED = 1,
+}
+impl From<EN_A> for bool {
+    #[inline(always)]
+    fn from(variant: EN_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EN_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EN_A {
+        match self.bits {
+            false => EN_A::DISABLED,
+            true => EN_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == EN_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == EN_A::ENABLED
+    }
+}
+#[doc = "Field `EN` writer - "]
+pub type EN_W<'a, const O: u8> = crate::BitWriter<'a, u32, PUBLISH_USBDETECTED_SPEC, EN_A, O>;
+impl<'a, const O: u8> EN_W<'a, O> {
+    #[doc = "Disable publishing"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(EN_A::DISABLED)
+    }
+    #[doc = "Enable publishing"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(EN_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:7 - DPPI channel that event USBDETECTED will publish to."]
+    #[inline(always)]
+    pub fn chidx(&self) -> CHIDX_R {
+        CHIDX_R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&self) -> EN_R {
+        EN_R::new(((self.bits >> 31) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - DPPI channel that event USBDETECTED will publish to."]
+    #[inline(always)]
+    pub fn chidx(&mut self) -> CHIDX_W<0> {
+        CHIDX_W::new(self)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&mut self) -> EN_W<31> {
+        EN_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Publish configuration for event USBDETECTED\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [publish_usbdetected](index.html) module"]
+pub struct PUBLISH_USBDETECTED_SPEC;
+impl crate::RegisterSpec for PUBLISH_USBDETECTED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [publish_usbdetected::R](R) reader structure"]
+impl crate::Readable for PUBLISH_USBDETECTED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [publish_usbdetected::W](W) writer structure"]
+impl crate::Writable for PUBLISH_USBDETECTED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PUBLISH_USBDETECTED to value 0"]
+impl crate::Resettable for PUBLISH_USBDETECTED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/publish_usbpwrrdy.rs

@@ -0,0 +1,141 @@
+#[doc = "Register `PUBLISH_USBPWRRDY` reader"]
+pub struct R(crate::R<PUBLISH_USBPWRRDY_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PUBLISH_USBPWRRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PUBLISH_USBPWRRDY_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PUBLISH_USBPWRRDY_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PUBLISH_USBPWRRDY` writer"]
+pub struct W(crate::W<PUBLISH_USBPWRRDY_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PUBLISH_USBPWRRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<PUBLISH_USBPWRRDY_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PUBLISH_USBPWRRDY_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CHIDX` reader - DPPI channel that event USBPWRRDY will publish to."]
+pub type CHIDX_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `CHIDX` writer - DPPI channel that event USBPWRRDY will publish to."]
+pub type CHIDX_W<'a, const O: u8> =
+    crate::FieldWriter<'a, u32, PUBLISH_USBPWRRDY_SPEC, u8, u8, 8, O>;
+#[doc = "Field `EN` reader - "]
+pub type EN_R = crate::BitReader<EN_A>;
+#[doc = "\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EN_A {
+    #[doc = "0: Disable publishing"]
+    DISABLED = 0,
+    #[doc = "1: Enable publishing"]
+    ENABLED = 1,
+}
+impl From<EN_A> for bool {
+    #[inline(always)]
+    fn from(variant: EN_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EN_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EN_A {
+        match self.bits {
+            false => EN_A::DISABLED,
+            true => EN_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == EN_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == EN_A::ENABLED
+    }
+}
+#[doc = "Field `EN` writer - "]
+pub type EN_W<'a, const O: u8> = crate::BitWriter<'a, u32, PUBLISH_USBPWRRDY_SPEC, EN_A, O>;
+impl<'a, const O: u8> EN_W<'a, O> {
+    #[doc = "Disable publishing"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(EN_A::DISABLED)
+    }
+    #[doc = "Enable publishing"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(EN_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:7 - DPPI channel that event USBPWRRDY will publish to."]
+    #[inline(always)]
+    pub fn chidx(&self) -> CHIDX_R {
+        CHIDX_R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&self) -> EN_R {
+        EN_R::new(((self.bits >> 31) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - DPPI channel that event USBPWRRDY will publish to."]
+    #[inline(always)]
+    pub fn chidx(&mut self) -> CHIDX_W<0> {
+        CHIDX_W::new(self)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&mut self) -> EN_W<31> {
+        EN_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Publish configuration for event USBPWRRDY\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [publish_usbpwrrdy](index.html) module"]
+pub struct PUBLISH_USBPWRRDY_SPEC;
+impl crate::RegisterSpec for PUBLISH_USBPWRRDY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [publish_usbpwrrdy::R](R) reader structure"]
+impl crate::Readable for PUBLISH_USBPWRRDY_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [publish_usbpwrrdy::W](W) writer structure"]
+impl crate::Writable for PUBLISH_USBPWRRDY_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PUBLISH_USBPWRRDY to value 0"]
+impl crate::Resettable for PUBLISH_USBPWRRDY_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/publish_usbremoved.rs

@@ -0,0 +1,141 @@
+#[doc = "Register `PUBLISH_USBREMOVED` reader"]
+pub struct R(crate::R<PUBLISH_USBREMOVED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PUBLISH_USBREMOVED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PUBLISH_USBREMOVED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PUBLISH_USBREMOVED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PUBLISH_USBREMOVED` writer"]
+pub struct W(crate::W<PUBLISH_USBREMOVED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PUBLISH_USBREMOVED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<PUBLISH_USBREMOVED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PUBLISH_USBREMOVED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CHIDX` reader - DPPI channel that event USBREMOVED will publish to."]
+pub type CHIDX_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `CHIDX` writer - DPPI channel that event USBREMOVED will publish to."]
+pub type CHIDX_W<'a, const O: u8> =
+    crate::FieldWriter<'a, u32, PUBLISH_USBREMOVED_SPEC, u8, u8, 8, O>;
+#[doc = "Field `EN` reader - "]
+pub type EN_R = crate::BitReader<EN_A>;
+#[doc = "\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EN_A {
+    #[doc = "0: Disable publishing"]
+    DISABLED = 0,
+    #[doc = "1: Enable publishing"]
+    ENABLED = 1,
+}
+impl From<EN_A> for bool {
+    #[inline(always)]
+    fn from(variant: EN_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EN_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EN_A {
+        match self.bits {
+            false => EN_A::DISABLED,
+            true => EN_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == EN_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == EN_A::ENABLED
+    }
+}
+#[doc = "Field `EN` writer - "]
+pub type EN_W<'a, const O: u8> = crate::BitWriter<'a, u32, PUBLISH_USBREMOVED_SPEC, EN_A, O>;
+impl<'a, const O: u8> EN_W<'a, O> {
+    #[doc = "Disable publishing"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(EN_A::DISABLED)
+    }
+    #[doc = "Enable publishing"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(EN_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:7 - DPPI channel that event USBREMOVED will publish to."]
+    #[inline(always)]
+    pub fn chidx(&self) -> CHIDX_R {
+        CHIDX_R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&self) -> EN_R {
+        EN_R::new(((self.bits >> 31) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - DPPI channel that event USBREMOVED will publish to."]
+    #[inline(always)]
+    pub fn chidx(&mut self) -> CHIDX_W<0> {
+        CHIDX_W::new(self)
+    }
+    #[doc = "Bit 31"]
+    #[inline(always)]
+    pub fn en(&mut self) -> EN_W<31> {
+        EN_W::new(self)
+    }
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Publish configuration for event USBREMOVED\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [publish_usbremoved](index.html) module"]
+pub struct PUBLISH_USBREMOVED_SPEC;
+impl crate::RegisterSpec for PUBLISH_USBREMOVED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [publish_usbremoved::R](R) reader structure"]
+impl crate::Readable for PUBLISH_USBREMOVED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [publish_usbremoved::W](W) writer structure"]
+impl crate::Writable for PUBLISH_USBREMOVED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PUBLISH_USBREMOVED to value 0"]
+impl crate::Resettable for PUBLISH_USBREMOVED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf5340-app-pac/src/usbregulator_ns/usbregstatus.rs

@@ -0,0 +1,115 @@
+#[doc = "Register `USBREGSTATUS` reader"]
+pub struct R(crate::R<USBREGSTATUS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<USBREGSTATUS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<USBREGSTATUS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<USBREGSTATUS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `VBUSDETECT` reader - VBUS input detection status (USBDETECTED and USBREMOVED events are derived from this information)"]
+pub type VBUSDETECT_R = crate::BitReader<VBUSDETECT_A>;
+#[doc = "VBUS input detection status (USBDETECTED and USBREMOVED events are derived from this information)\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum VBUSDETECT_A {
+    #[doc = "0: VBUS voltage below valid threshold"]
+    NO_VBUS = 0,
+    #[doc = "1: VBUS voltage above valid threshold"]
+    VBUS_PRESENT = 1,
+}
+impl From<VBUSDETECT_A> for bool {
+    #[inline(always)]
+    fn from(variant: VBUSDETECT_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl VBUSDETECT_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> VBUSDETECT_A {
+        match self.bits {
+            false => VBUSDETECT_A::NO_VBUS,
+            true => VBUSDETECT_A::VBUS_PRESENT,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NO_VBUS`"]
+    #[inline(always)]
+    pub fn is_no_vbus(&self) -> bool {
+        *self == VBUSDETECT_A::NO_VBUS
+    }
+    #[doc = "Checks if the value of the field is `VBUS_PRESENT`"]
+    #[inline(always)]
+    pub fn is_vbus_present(&self) -> bool {
+        *self == VBUSDETECT_A::VBUS_PRESENT
+    }
+}
+#[doc = "Field `OUTPUTRDY` reader - USB supply output settling time elapsed"]
+pub type OUTPUTRDY_R = crate::BitReader<OUTPUTRDY_A>;
+#[doc = "USB supply output settling time elapsed\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OUTPUTRDY_A {
+    #[doc = "0: USBREG output settling time not elapsed"]
+    NOT_READY = 0,
+    #[doc = "1: USBREG output settling time elapsed (same information as USBPWRRDY event)"]
+    READY = 1,
+}
+impl From<OUTPUTRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: OUTPUTRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl OUTPUTRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> OUTPUTRDY_A {
+        match self.bits {
+            false => OUTPUTRDY_A::NOT_READY,
+            true => OUTPUTRDY_A::READY,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_READY`"]
+    #[inline(always)]
+    pub fn is_not_ready(&self) -> bool {
+        *self == OUTPUTRDY_A::NOT_READY
+    }
+    #[doc = "Checks if the value of the field is `READY`"]
+    #[inline(always)]
+    pub fn is_ready(&self) -> bool {
+        *self == OUTPUTRDY_A::READY
+    }
+}
+impl R {
+    #[doc = "Bit 0 - VBUS input detection status (USBDETECTED and USBREMOVED events are derived from this information)"]
+    #[inline(always)]
+    pub fn vbusdetect(&self) -> VBUSDETECT_R {
+        VBUSDETECT_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - USB supply output settling time elapsed"]
+    #[inline(always)]
+    pub fn outputrdy(&self) -> OUTPUTRDY_R {
+        OUTPUTRDY_R::new(((self.bits >> 1) & 1) != 0)
+    }
+}
+#[doc = "USB supply status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [usbregstatus](index.html) module"]
+pub struct USBREGSTATUS_SPEC;
+impl crate::RegisterSpec for USBREGSTATUS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [usbregstatus::R](R) reader structure"]
+impl crate::Readable for USBREGSTATUS_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets USBREGSTATUS to value 0"]
+impl crate::Resettable for USBREGSTATUS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}