Merge #842

842: WIP: Make unborrow safe to use r=Dirbaio a=GrantM11235

The basic idea is that `Unborrow::unborrow` is now safe to call and returns an `Unborrowed<'a, T>` which impls `Deref` and `DerefMut`

```rust
/// This is essentially a `&mut T`, but it is the size of `T` not the size
/// of a pointer. This is useful if T is a zero sized type.
pub struct Unborrowed<'a, T> {
    inner: T,
    _lifetime: PhantomData<&'a mut T>,
}
```

## Todo

- [x] Update other crates
  - [x] embassy-cortex-m
  - [x] embassy-hal-common
  - [x] embassy-lora
  - [x] embassy-nrf
  - [x] embassy-rp
  - [x] embassy-stm32
- [x] Remove usage of the unsafe `into_inner` method if possible
- [x] Review and amend docs for `Unborrow` and `Unborrowed`

Co-authored-by: Grant Miller <[email protected]>
Co-authored-by: Dario Nieuwenhuis <[email protected]>

19 files changed, 505 insertions, 546 deletions

diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs
index 4fc78b95d..89c1ba908 100644
--- a/embassy-nrf/src/buffered_uarte.rs
+++ b/embassy-nrf/src/buffered_uarte.rs
@@ -15,14 +15,13 @@
 
 use core::cmp::min;
 use core::future::Future;
-use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy::waitqueue::WakerRegistration;
 use embassy_cortex_m::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
 use embassy_hal_common::ring_buffer::RingBuffer;
-use embassy_hal_common::{low_power_wait_until, unborrow};
+use embassy_hal_common::{into_ref, low_power_wait_until, PeripheralRef};
 use futures::future::poll_fn;
 // Re-export SVD variants to allow user to directly set values
 pub use pac::uarte0::{baudrate::BAUDRATE_A as Baudrate, config::PARITY_A as Parity};
@@ -32,7 +31,7 @@ use crate::interrupt::InterruptExt;
 use crate::ppi::{AnyConfigurableChannel, ConfigurableChannel, Event, Ppi, Task};
 use crate::timer::{Frequency, Instance as TimerInstance, Timer};
 use crate::uarte::{apply_workaround_for_enable_anomaly, Config, Instance as UarteInstance};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 enum RxState {
@@ -54,7 +53,7 @@ impl<'d, U: UarteInstance, T: TimerInstance> State<'d, U, T> {
 }
 
 struct StateInner<'d, U: UarteInstance, T: TimerInstance> {
-    phantom: PhantomData<&'d mut U>,
+    _peri: PeripheralRef<'d, U>,
     timer: Timer<'d, T>,
     _ppi_ch1: Ppi<'d, AnyConfigurableChannel, 1, 2>,
     _ppi_ch2: Ppi<'d, AnyConfigurableChannel, 1, 1>,
@@ -78,20 +77,20 @@ impl<'d, U: UarteInstance, T: TimerInstance> Unpin for BufferedUarte<'d, U, T> {
 impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
     pub fn new(
         state: &'d mut State<'d, U, T>,
-        _uarte: impl Unborrow<Target = U> + 'd,
-        timer: impl Unborrow<Target = T> + 'd,
-        ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        ppi_ch2: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        irq: impl Unborrow<Target = U::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
-        cts: impl Unborrow<Target = impl GpioPin> + 'd,
-        rts: impl Unborrow<Target = impl GpioPin> + 'd,
+        peri: impl Peripheral<P = U> + 'd,
+        timer: impl Peripheral<P = T> + 'd,
+        ppi_ch1: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        ppi_ch2: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        irq: impl Peripheral<P = U::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
+        cts: impl Peripheral<P = impl GpioPin> + 'd,
+        rts: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
         rx_buffer: &'d mut [u8],
         tx_buffer: &'d mut [u8],
     ) -> Self {
-        unborrow!(ppi_ch1, ppi_ch2, irq, rxd, txd, cts, rts);
+        into_ref!(peri, ppi_ch1, ppi_ch2, irq, rxd, txd, cts, rts);
 
         let r = U::regs();
 
@@ -147,7 +146,7 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
         timer.cc(0).short_compare_stop();
 
         let mut ppi_ch1 = Ppi::new_one_to_two(
-            ppi_ch1.degrade(),
+            ppi_ch1.map_into(),
             Event::from_reg(&r.events_rxdrdy),
             timer.task_clear(),
             timer.task_start(),
@@ -155,7 +154,7 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
         ppi_ch1.enable();
 
         let mut ppi_ch2 = Ppi::new_one_to_one(
-            ppi_ch2.degrade(),
+            ppi_ch2.map_into(),
             timer.cc(0).event_compare(),
             Task::from_reg(&r.tasks_stoprx),
         );
@@ -163,7 +162,7 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
 
         Self {
             inner: PeripheralMutex::new(irq, &mut state.0, move || StateInner {
-                phantom: PhantomData,
+                _peri: peri,
                 timer,
                 _ppi_ch1: ppi_ch1,
                 _ppi_ch2: ppi_ch2,
diff --git a/embassy-nrf/src/gpio.rs b/embassy-nrf/src/gpio.rs
index fd4ae2ec3..a61ff6aa5 100644
--- a/embassy-nrf/src/gpio.rs
+++ b/embassy-nrf/src/gpio.rs
@@ -2,15 +2,14 @@
 
 use core::convert::Infallible;
 use core::hint::unreachable_unchecked;
-use core::marker::PhantomData;
 
 use cfg_if::cfg_if;
-use embassy_hal_common::{unborrow, unsafe_impl_unborrow};
+use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
 
 use self::sealed::Pin as _;
 use crate::pac::p0 as gpio;
 use crate::pac::p0::pin_cnf::{DRIVE_A, PULL_A};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 /// A GPIO port with up to 32 pins.
 #[derive(Debug, Eq, PartialEq)]
@@ -39,7 +38,7 @@ pub struct Input<'d, T: Pin> {
 
 impl<'d, T: Pin> Input<'d, T> {
     #[inline]
-    pub fn new(pin: impl Unborrow<Target = T> + 'd, pull: Pull) -> Self {
+    pub fn new(pin: impl Peripheral<P = T> + 'd, pull: Pull) -> Self {
         let mut pin = Flex::new(pin);
         pin.set_as_input(pull);
 
@@ -119,7 +118,7 @@ pub struct Output<'d, T: Pin> {
 
 impl<'d, T: Pin> Output<'d, T> {
     #[inline]
-    pub fn new(pin: impl Unborrow<Target = T> + 'd, initial_output: Level, drive: OutputDrive) -> Self {
+    pub fn new(pin: impl Peripheral<P = T> + 'd, initial_output: Level, drive: OutputDrive) -> Self {
         let mut pin = Flex::new(pin);
         match initial_output {
             Level::High => pin.set_high(),
@@ -194,8 +193,7 @@ fn convert_pull(pull: Pull) -> PULL_A {
 /// set while not in output mode, so the pin's level will be 'remembered' when it is not in output
 /// mode.
 pub struct Flex<'d, T: Pin> {
-    pub(crate) pin: T,
-    phantom: PhantomData<&'d mut T>,
+    pub(crate) pin: PeripheralRef<'d, T>,
 }
 
 impl<'d, T: Pin> Flex<'d, T> {
@@ -204,13 +202,10 @@ impl<'d, T: Pin> Flex<'d, T> {
     /// The pin remains disconnected. The initial output level is unspecified, but can be changed
     /// before the pin is put into output mode.
     #[inline]
-    pub fn new(pin: impl Unborrow<Target = T> + 'd) -> Self {
-        unborrow!(pin);
+    pub fn new(pin: impl Peripheral<P = T> + 'd) -> Self {
+        into_ref!(pin);
         // Pin will be in disconnected state.
-        Self {
-            pin,
-            phantom: PhantomData,
-        }
+        Self { pin }
     }
 
     /// Put the pin into input mode.
@@ -379,7 +374,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Pin: Unborrow<Target = Self> + sealed::Pin + Sized + 'static {
+pub trait Pin: Peripheral<P = Self> + Into<AnyPin> + sealed::Pin + Sized + 'static {
     /// Number of the pin within the port (0..31)
     #[inline]
     fn pin(&self) -> u8 {
@@ -423,7 +418,7 @@ impl AnyPin {
     }
 }
 
-unsafe_impl_unborrow!(AnyPin);
+impl_peripheral!(AnyPin);
 impl Pin for AnyPin {}
 impl sealed::Pin for AnyPin {
     #[inline]
@@ -438,10 +433,13 @@ pub(crate) trait PselBits {
     fn psel_bits(&self) -> u32;
 }
 
-impl PselBits for Option<AnyPin> {
+impl<'a, P: Pin> PselBits for Option<PeripheralRef<'a, P>> {
     #[inline]
     fn psel_bits(&self) -> u32 {
-        self.as_ref().map_or(1u32 << 31, Pin::psel_bits)
+        match self {
+            Some(pin) => pin.psel_bits(),
+            None => 1u32 << 31,
+        }
     }
 }
 
@@ -463,6 +461,12 @@ macro_rules! impl_pin {
                 $port_num * 32 + $pin_num
             }
         }
+
+        impl From<peripherals::$type> for crate::gpio::AnyPin {
+            fn from(val: peripherals::$type) -> Self {
+                crate::gpio::Pin::degrade(val)
+            }
+        }
     };
 }
 
diff --git a/embassy-nrf/src/gpiote.rs b/embassy-nrf/src/gpiote.rs
index d4e1cb35c..cef80ae0a 100644
--- a/embassy-nrf/src/gpiote.rs
+++ b/embassy-nrf/src/gpiote.rs
@@ -1,10 +1,9 @@
 use core::convert::Infallible;
 use core::future::Future;
-use core::marker::PhantomData;
 use core::task::{Context, Poll};
 
 use embassy::waitqueue::AtomicWaker;
-use embassy_hal_common::unsafe_impl_unborrow;
+use embassy_hal_common::{impl_peripheral, Peripheral, PeripheralRef};
 use futures::future::poll_fn;
 
 use crate::gpio::sealed::Pin as _;
@@ -301,16 +300,22 @@ impl<'d, C: Channel, T: GpioPin> OutputChannel<'d, C, T> {
 // =======================
 
 pub(crate) struct PortInputFuture<'a> {
-    pin_port: u8,
-    phantom: PhantomData<&'a mut AnyPin>,
+    pin: PeripheralRef<'a, AnyPin>,
+}
+
+impl<'a> PortInputFuture<'a> {
+    fn new(pin: impl Peripheral<P = impl GpioPin> + 'a) -> Self {
+        Self {
+            pin: pin.into_ref().map_into(),
+        }
+    }
 }
 
 impl<'a> Unpin for PortInputFuture<'a> {}
 
 impl<'a> Drop for PortInputFuture<'a> {
     fn drop(&mut self) {
-        let pin = unsafe { AnyPin::steal(self.pin_port) };
-        pin.conf().modify(|_, w| w.sense().disabled());
+        self.pin.conf().modify(|_, w| w.sense().disabled());
     }
 }
 
@@ -318,10 +323,9 @@ impl<'a> Future for PortInputFuture<'a> {
     type Output = ();
 
     fn poll(self: core::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        PORT_WAKERS[self.pin_port as usize].register(cx.waker());
+        PORT_WAKERS[self.pin.pin_port() as usize].register(cx.waker());
 
-        let pin = unsafe { AnyPin::steal(self.pin_port) };
-        if pin.conf().read().sense().is_disabled() {
+        if self.pin.conf().read().sense().is_disabled() {
             Poll::Ready(())
         } else {
             Poll::Pending
@@ -354,22 +358,12 @@ impl<'d, T: GpioPin> Input<'d, T> {
 impl<'d, T: GpioPin> Flex<'d, T> {
     pub async fn wait_for_high(&mut self) {
         self.pin.conf().modify(|_, w| w.sense().high());
-
-        PortInputFuture {
-            pin_port: self.pin.pin_port(),
-            phantom: PhantomData,
-        }
-        .await
+        PortInputFuture::new(&mut self.pin).await
     }
 
     pub async fn wait_for_low(&mut self) {
         self.pin.conf().modify(|_, w| w.sense().low());
-
-        PortInputFuture {
-            pin_port: self.pin.pin_port(),
-            phantom: PhantomData,
-        }
-        .await
+        PortInputFuture::new(&mut self.pin).await
     }
 
     pub async fn wait_for_rising_edge(&mut self) {
@@ -388,11 +382,7 @@ impl<'d, T: GpioPin> Flex<'d, T> {
         } else {
             self.pin.conf().modify(|_, w| w.sense().high());
         }
-        PortInputFuture {
-            pin_port: self.pin.pin_port(),
-            phantom: PhantomData,
-        }
-        .await
+        PortInputFuture::new(&mut self.pin).await
     }
 }
 
@@ -414,7 +404,7 @@ pub trait Channel: sealed::Channel + Sized {
 pub struct AnyChannel {
     number: u8,
 }
-unsafe_impl_unborrow!(AnyChannel);
+impl_peripheral!(AnyChannel);
 impl sealed::Channel for AnyChannel {}
 impl Channel for AnyChannel {
     fn number(&self) -> usize {
diff --git a/embassy-nrf/src/lib.rs b/embassy-nrf/src/lib.rs
index 3699ad0fa..ad6c16c1f 100644
--- a/embassy-nrf/src/lib.rs
+++ b/embassy-nrf/src/lib.rs
@@ -135,7 +135,7 @@ pub use chip::pac;
 pub(crate) use chip::pac;
 pub use chip::{peripherals, Peripherals};
 pub use embassy_cortex_m::executor;
-pub use embassy_hal_common::{unborrow, Unborrow};
+pub use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
 pub use embassy_macros::cortex_m_interrupt as interrupt;
 
 pub mod config {
diff --git a/embassy-nrf/src/nvmc.rs b/embassy-nrf/src/nvmc.rs
index e350f8c99..cd6100339 100644
--- a/embassy-nrf/src/nvmc.rs
+++ b/embassy-nrf/src/nvmc.rs
@@ -1,15 +1,14 @@
 //! Nvmcerature sensor interface.
 
-use core::marker::PhantomData;
 use core::{ptr, slice};
 
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use embedded_storage::nor_flash::{
     ErrorType, MultiwriteNorFlash, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash,
 };
 
 use crate::peripherals::NVMC;
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 pub const PAGE_SIZE: usize = 4096;
 pub const FLASH_SIZE: usize = crate::chip::FLASH_SIZE;
@@ -31,14 +30,13 @@ impl NorFlashError for Error {
 }
 
 pub struct Nvmc<'d> {
-    _p: PhantomData<&'d NVMC>,
+    _p: PeripheralRef<'d, NVMC>,
 }
 
 impl<'d> Nvmc<'d> {
-    pub fn new(_p: impl Unborrow<Target = NVMC> + 'd) -> Self {
-        unborrow!(_p);
-
-        Self { _p: PhantomData }
+    pub fn new(_p: impl Peripheral<P = NVMC> + 'd) -> Self {
+        into_ref!(_p);
+        Self { _p }
     }
 
     fn regs() -> &'static pac::nvmc::RegisterBlock {
diff --git a/embassy-nrf/src/ppi/dppi.rs b/embassy-nrf/src/ppi/dppi.rs
index d0bffb1e0..de856c0ca 100644
--- a/embassy-nrf/src/ppi/dppi.rs
+++ b/embassy-nrf/src/ppi/dppi.rs
@@ -1,9 +1,7 @@
-use core::marker::PhantomData;
-
-use embassy_hal_common::unborrow;
+use embassy_hal_common::into_ref;
 
 use super::{Channel, ConfigurableChannel, Event, Ppi, Task};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 const DPPI_ENABLE_BIT: u32 = 0x8000_0000;
 const DPPI_CHANNEL_MASK: u32 = 0x0000_00FF;
@@ -13,13 +11,13 @@ fn regs() -> &'static pac::dppic::RegisterBlock {
 }
 
 impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 1> {
-    pub fn new_one_to_one(ch: impl Unborrow<Target = C> + 'd, event: Event, task: Task) -> Self {
+    pub fn new_one_to_one(ch: impl Peripheral<P = C> + 'd, event: Event, task: Task) -> Self {
         Ppi::new_many_to_many(ch, [event], [task])
     }
 }
 
 impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 2> {
-    pub fn new_one_to_two(ch: impl Unborrow<Target = C> + 'd, event: Event, task1: Task, task2: Task) -> Self {
+    pub fn new_one_to_two(ch: impl Peripheral<P = C> + 'd, event: Event, task1: Task, task2: Task) -> Self {
         Ppi::new_many_to_many(ch, [event], [task1, task2])
     }
 }
@@ -28,11 +26,11 @@ impl<'d, C: ConfigurableChannel, const EVENT_COUNT: usize, const TASK_COUNT: usi
     Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
 {
     pub fn new_many_to_many(
-        ch: impl Unborrow<Target = C> + 'd,
+        ch: impl Peripheral<P = C> + 'd,
         events: [Event; EVENT_COUNT],
         tasks: [Task; TASK_COUNT],
     ) -> Self {
-        unborrow!(ch);
+        into_ref!(ch);
 
         let val = DPPI_ENABLE_BIT | (ch.number() as u32 & DPPI_CHANNEL_MASK);
         for task in tasks {
@@ -48,12 +46,7 @@ impl<'d, C: ConfigurableChannel, const EVENT_COUNT: usize, const TASK_COUNT: usi
             unsafe { event.publish_reg().write_volatile(val) }
         }
 
-        Self {
-            ch,
-            events,
-            tasks,
-            phantom: PhantomData,
-        }
+        Self { ch, events, tasks }
     }
 }
 
diff --git a/embassy-nrf/src/ppi/mod.rs b/embassy-nrf/src/ppi/mod.rs
index 660db6410..23ab011bc 100644
--- a/embassy-nrf/src/ppi/mod.rs
+++ b/embassy-nrf/src/ppi/mod.rs
@@ -15,12 +15,11 @@
 //! many tasks and events, but any single task or event can only be coupled with one channel.
 //!
 
-use core::marker::PhantomData;
 use core::ptr::NonNull;
 
-use embassy_hal_common::unsafe_impl_unborrow;
+use embassy_hal_common::{impl_peripheral, PeripheralRef};
 
-use crate::{peripherals, Unborrow};
+use crate::{peripherals, Peripheral};
 
 #[cfg(feature = "_dppi")]
 mod dppi;
@@ -28,12 +27,11 @@ mod dppi;
 mod ppi;
 
 pub struct Ppi<'d, C: Channel, const EVENT_COUNT: usize, const TASK_COUNT: usize> {
-    ch: C,
+    ch: PeripheralRef<'d, C>,
     #[cfg(feature = "_dppi")]
     events: [Event; EVENT_COUNT],
     #[cfg(feature = "_dppi")]
     tasks: [Task; TASK_COUNT],
-    phantom: PhantomData<&'d mut C>,
 }
 
 const REGISTER_DPPI_CONFIG_OFFSET: usize = 0x80 / core::mem::size_of::<u32>();
@@ -89,16 +87,16 @@ pub(crate) mod sealed {
     pub trait Group {}
 }
 
-pub trait Channel: sealed::Channel + Unborrow<Target = Self> + Sized {
+pub trait Channel: sealed::Channel + Peripheral<P = Self> + Sized {
     /// Returns the number of the channel
     fn number(&self) -> usize;
 }
 
-pub trait ConfigurableChannel: Channel {
+pub trait ConfigurableChannel: Channel + Into<AnyConfigurableChannel> {
     fn degrade(self) -> AnyConfigurableChannel;
 }
 
-pub trait StaticChannel: Channel {
+pub trait StaticChannel: Channel + Into<AnyStaticChannel> {
     fn degrade(self) -> AnyStaticChannel;
 }
 
@@ -119,7 +117,7 @@ pub trait Group: sealed::Group + Sized {
 pub struct AnyStaticChannel {
     pub(crate) number: u8,
 }
-unsafe_impl_unborrow!(AnyStaticChannel);
+impl_peripheral!(AnyStaticChannel);
 impl sealed::Channel for AnyStaticChannel {}
 impl Channel for AnyStaticChannel {
     fn number(&self) -> usize {
@@ -137,7 +135,7 @@ impl StaticChannel for AnyStaticChannel {
 pub struct AnyConfigurableChannel {
     pub(crate) number: u8,
 }
-unsafe_impl_unborrow!(AnyConfigurableChannel);
+impl_peripheral!(AnyConfigurableChannel);
 impl sealed::Channel for AnyConfigurableChannel {}
 impl Channel for AnyConfigurableChannel {
     fn number(&self) -> usize {
@@ -169,6 +167,12 @@ macro_rules! impl_ppi_channel {
                 }
             }
         }
+
+        impl From<peripherals::$type> for crate::ppi::AnyStaticChannel {
+            fn from(val: peripherals::$type) -> Self {
+                crate::ppi::StaticChannel::degrade(val)
+            }
+        }
     };
     ($type:ident, $number:expr => configurable) => {
         impl_ppi_channel!($type, $number);
@@ -180,6 +184,12 @@ macro_rules! impl_ppi_channel {
                 }
             }
         }
+
+        impl From<peripherals::$type> for crate::ppi::AnyConfigurableChannel {
+            fn from(val: peripherals::$type) -> Self {
+                crate::ppi::ConfigurableChannel::degrade(val)
+            }
+        }
     };
 }
 
@@ -189,7 +199,7 @@ macro_rules! impl_ppi_channel {
 pub struct AnyGroup {
     number: u8,
 }
-unsafe_impl_unborrow!(AnyGroup);
+impl_peripheral!(AnyGroup);
 impl sealed::Group for AnyGroup {}
 impl Group for AnyGroup {
     fn number(&self) -> usize {
diff --git a/embassy-nrf/src/ppi/ppi.rs b/embassy-nrf/src/ppi/ppi.rs
index e5c86d444..450a290a2 100644
--- a/embassy-nrf/src/ppi/ppi.rs
+++ b/embassy-nrf/src/ppi/ppi.rs
@@ -1,9 +1,7 @@
-use core::marker::PhantomData;
-
-use embassy_hal_common::unborrow;
+use embassy_hal_common::into_ref;
 
 use super::{Channel, ConfigurableChannel, Event, Ppi, StaticChannel, Task};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 impl Task {
     fn reg_val(&self) -> u32 {
@@ -22,40 +20,34 @@ fn regs() -> &'static pac::ppi::RegisterBlock {
 
 #[cfg(not(feature = "nrf51"))] // Not for nrf51 because of the fork task
 impl<'d, C: StaticChannel> Ppi<'d, C, 0, 1> {
-    pub fn new_zero_to_one(ch: impl Unborrow<Target = C> + 'd, task: Task) -> Self {
-        unborrow!(ch);
+    pub fn new_zero_to_one(ch: impl Peripheral<P = C> + 'd, task: Task) -> Self {
+        into_ref!(ch);
 
         let r = regs();
         let n = ch.number();
         r.fork[n].tep.write(|w| unsafe { w.bits(task.reg_val()) });
 
-        Self {
-            ch,
-            phantom: PhantomData,
-        }
+        Self { ch }
     }
 }
 
 impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 1> {
-    pub fn new_one_to_one(ch: impl Unborrow<Target = C> + 'd, event: Event, task: Task) -> Self {
-        unborrow!(ch);
+    pub fn new_one_to_one(ch: impl Peripheral<P = C> + 'd, event: Event, task: Task) -> Self {
+        into_ref!(ch);
 
         let r = regs();
         let n = ch.number();
         r.ch[n].eep.write(|w| unsafe { w.bits(event.reg_val()) });
         r.ch[n].tep.write(|w| unsafe { w.bits(task.reg_val()) });
 
-        Self {
-            ch,
-            phantom: PhantomData,
-        }
+        Self { ch }
     }
 }
 
 #[cfg(not(feature = "nrf51"))] // Not for nrf51 because of the fork task
 impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 2> {
-    pub fn new_one_to_two(ch: impl Unborrow<Target = C> + 'd, event: Event, task1: Task, task2: Task) -> Self {
-        unborrow!(ch);
+    pub fn new_one_to_two(ch: impl Peripheral<P = C> + 'd, event: Event, task1: Task, task2: Task) -> Self {
+        into_ref!(ch);
 
         let r = regs();
         let n = ch.number();
@@ -63,10 +55,7 @@ impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 2> {
         r.ch[n].tep.write(|w| unsafe { w.bits(task1.reg_val()) });
         r.fork[n].tep.write(|w| unsafe { w.bits(task2.reg_val()) });
 
-        Self {
-            ch,
-            phantom: PhantomData,
-        }
+        Self { ch }
     }
 }
 
diff --git a/embassy-nrf/src/pwm.rs b/embassy-nrf/src/pwm.rs
index 9a78ff1f1..5f750a91e 100644
--- a/embassy-nrf/src/pwm.rs
+++ b/embassy-nrf/src/pwm.rs
@@ -1,36 +1,35 @@
 #![macro_use]
 
-use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{AnyPin, Pin as GpioPin, PselBits};
 use crate::interrupt::Interrupt;
 use crate::ppi::{Event, Task};
 use crate::util::slice_in_ram_or;
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 /// SimplePwm is the traditional pwm interface you're probably used to, allowing
 /// to simply set a duty cycle across up to four channels.
 pub struct SimplePwm<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
+    _peri: PeripheralRef<'d, T>,
     duty: [u16; 4],
-    ch0: Option<AnyPin>,
-    ch1: Option<AnyPin>,
-    ch2: Option<AnyPin>,
-    ch3: Option<AnyPin>,
+    ch0: Option<PeripheralRef<'d, AnyPin>>,
+    ch1: Option<PeripheralRef<'d, AnyPin>>,
+    ch2: Option<PeripheralRef<'d, AnyPin>>,
+    ch3: Option<PeripheralRef<'d, AnyPin>>,
 }
 
 /// SequencePwm allows you to offload the updating of a sequence of duty cycles
 /// to up to four channels, as well as repeat that sequence n times.
 pub struct SequencePwm<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
-    ch0: Option<AnyPin>,
-    ch1: Option<AnyPin>,
-    ch2: Option<AnyPin>,
-    ch3: Option<AnyPin>,
+    _peri: PeripheralRef<'d, T>,
+    ch0: Option<PeripheralRef<'d, AnyPin>>,
+    ch1: Option<PeripheralRef<'d, AnyPin>>,
+    ch2: Option<PeripheralRef<'d, AnyPin>>,
+    ch3: Option<PeripheralRef<'d, AnyPin>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -51,41 +50,41 @@ impl<'d, T: Instance> SequencePwm<'d, T> {
     /// Create a new 1-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_1ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Result<Self, Error> {
-        unborrow!(ch0);
-        Self::new_inner(pwm, Some(ch0.degrade()), None, None, None, config)
+        into_ref!(ch0);
+        Self::new_inner(pwm, Some(ch0.map_into()), None, None, None, config)
     }
 
     /// Create a new 2-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_2ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Result<Self, Error> {
-        unborrow!(ch0, ch1);
-        Self::new_inner(pwm, Some(ch0.degrade()), Some(ch1.degrade()), None, None, config)
+        into_ref!(ch0, ch1);
+        Self::new_inner(pwm, Some(ch0.map_into()), Some(ch1.map_into()), None, None, config)
     }
 
     /// Create a new 3-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_3ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch2: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
+        ch2: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Result<Self, Error> {
-        unborrow!(ch0, ch1, ch2);
+        into_ref!(ch0, ch1, ch2);
         Self::new_inner(
             pwm,
-            Some(ch0.degrade()),
-            Some(ch1.degrade()),
-            Some(ch2.degrade()),
+            Some(ch0.map_into()),
+            Some(ch1.map_into()),
+            Some(ch2.map_into()),
             None,
             config,
         )
@@ -94,32 +93,34 @@ impl<'d, T: Instance> SequencePwm<'d, T> {
     /// Create a new 4-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_4ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch2: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch3: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
+        ch2: impl Peripheral<P = impl GpioPin> + 'd,
+        ch3: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Result<Self, Error> {
-        unborrow!(ch0, ch1, ch2, ch3);
+        into_ref!(ch0, ch1, ch2, ch3);
         Self::new_inner(
             pwm,
-            Some(ch0.degrade()),
-            Some(ch1.degrade()),
-            Some(ch2.degrade()),
-            Some(ch3.degrade()),
+            Some(ch0.map_into()),
+            Some(ch1.map_into()),
+            Some(ch2.map_into()),
+            Some(ch3.map_into()),
             config,
         )
     }
 
     fn new_inner(
-        _pwm: impl Unborrow<Target = T> + 'd,
-        ch0: Option<AnyPin>,
-        ch1: Option<AnyPin>,
-        ch2: Option<AnyPin>,
-        ch3: Option<AnyPin>,
+        _pwm: impl Peripheral<P = T> + 'd,
+        ch0: Option<PeripheralRef<'d, AnyPin>>,
+        ch1: Option<PeripheralRef<'d, AnyPin>>,
+        ch2: Option<PeripheralRef<'d, AnyPin>>,
+        ch3: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Result<Self, Error> {
+        into_ref!(_pwm);
+
         let r = T::regs();
 
         if let Some(pin) = &ch0 {
@@ -168,7 +169,7 @@ impl<'d, T: Instance> SequencePwm<'d, T> {
         r.countertop.write(|w| unsafe { w.countertop().bits(config.max_duty) });
 
         Ok(Self {
-            phantom: PhantomData,
+            _peri: _pwm,
             ch0,
             ch1,
             ch2,
@@ -573,60 +574,74 @@ pub enum CounterMode {
 impl<'d, T: Instance> SimplePwm<'d, T> {
     /// Create a new 1-channel PWM
     #[allow(unused_unsafe)]
-    pub fn new_1ch(pwm: impl Unborrow<Target = T> + 'd, ch0: impl Unborrow<Target = impl GpioPin> + 'd) -> Self {
-        unborrow!(ch0);
-        Self::new_inner(pwm, Some(ch0.degrade()), None, None, None)
+    pub fn new_1ch(pwm: impl Peripheral<P = T> + 'd, ch0: impl Peripheral<P = impl GpioPin> + 'd) -> Self {
+        unsafe {
+            into_ref!(ch0);
+            Self::new_inner(pwm, Some(ch0.map_into()), None, None, None)
+        }
     }
 
     /// Create a new 2-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_2ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
     ) -> Self {
-        unborrow!(ch0, ch1);
-        Self::new_inner(pwm, Some(ch0.degrade()), Some(ch1.degrade()), None, None)
+        into_ref!(ch0, ch1);
+        Self::new_inner(pwm, Some(ch0.map_into()), Some(ch1.map_into()), None, None)
     }
 
     /// Create a new 3-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_3ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch2: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
+        ch2: impl Peripheral<P = impl GpioPin> + 'd,
     ) -> Self {
-        unborrow!(ch0, ch1, ch2);
-        Self::new_inner(pwm, Some(ch0.degrade()), Some(ch1.degrade()), Some(ch2.degrade()), None)
+        unsafe {
+            into_ref!(ch0, ch1, ch2);
+            Self::new_inner(
+                pwm,
+                Some(ch0.map_into()),
+                Some(ch1.map_into()),
+                Some(ch2.map_into()),
+                None,
+            )
+        }
     }
 
     /// Create a new 4-channel PWM
     #[allow(unused_unsafe)]
     pub fn new_4ch(
-        pwm: impl Unborrow<Target = T> + 'd,
-        ch0: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch1: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch2: impl Unborrow<Target = impl GpioPin> + 'd,
-        ch3: impl Unborrow<Target = impl GpioPin> + 'd,
+        pwm: impl Peripheral<P = T> + 'd,
+        ch0: impl Peripheral<P = impl GpioPin> + 'd,
+        ch1: impl Peripheral<P = impl GpioPin> + 'd,
+        ch2: impl Peripheral<P = impl GpioPin> + 'd,
+        ch3: impl Peripheral<P = impl GpioPin> + 'd,
     ) -> Self {
-        unborrow!(ch0, ch1, ch2, ch3);
-        Self::new_inner(
-            pwm,
-            Some(ch0.degrade()),
-            Some(ch1.degrade()),
-            Some(ch2.degrade()),
-            Some(ch3.degrade()),
-        )
+        unsafe {
+            into_ref!(ch0, ch1, ch2, ch3);
+            Self::new_inner(
+                pwm,
+                Some(ch0.map_into()),
+                Some(ch1.map_into()),
+                Some(ch2.map_into()),
+                Some(ch3.map_into()),
+            )
+        }
     }
 
     fn new_inner(
-        _pwm: impl Unborrow<Target = T> + 'd,
-        ch0: Option<AnyPin>,
-        ch1: Option<AnyPin>,
-        ch2: Option<AnyPin>,
-        ch3: Option<AnyPin>,
+        _pwm: impl Peripheral<P = T> + 'd,
+        ch0: Option<PeripheralRef<'d, AnyPin>>,
+        ch1: Option<PeripheralRef<'d, AnyPin>>,
+        ch2: Option<PeripheralRef<'d, AnyPin>>,
+        ch3: Option<PeripheralRef<'d, AnyPin>>,
     ) -> Self {
+        into_ref!(_pwm);
+
         let r = T::regs();
 
         if let Some(pin) = &ch0 {
@@ -654,7 +669,7 @@ impl<'d, T: Instance> SimplePwm<'d, T> {
         r.psel.out[3].write(|w| unsafe { w.bits(ch3.psel_bits()) });
 
         let pwm = Self {
-            phantom: PhantomData,
+            _peri: _pwm,
             ch0,
             ch1,
             ch2,
@@ -813,7 +828,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static {
     type Interrupt: Interrupt;
 }
 
diff --git a/embassy-nrf/src/qdec.rs b/embassy-nrf/src/qdec.rs
index e254328a6..f6daec252 100644
--- a/embassy-nrf/src/qdec.rs
+++ b/embassy-nrf/src/qdec.rs
@@ -1,21 +1,20 @@
 //! Quadrature decoder interface
 
-use core::marker::PhantomData;
 use core::task::Poll;
 
 use embassy::waitqueue::AtomicWaker;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{AnyPin, Pin as GpioPin};
 use crate::interrupt::InterruptExt;
 use crate::peripherals::QDEC;
-use crate::{interrupt, pac, Unborrow};
+use crate::{interrupt, pac, Peripheral};
 
 /// Quadrature decoder
 pub struct Qdec<'d> {
-    phantom: PhantomData<&'d QDEC>,
+    _p: PeripheralRef<'d, QDEC>,
 }
 
 #[non_exhaustive]
@@ -43,37 +42,37 @@ static WAKER: AtomicWaker = AtomicWaker::new();
 
 impl<'d> Qdec<'d> {
     pub fn new(
-        qdec: impl Unborrow<Target = QDEC> + 'd,
-        irq: impl Unborrow<Target = interrupt::QDEC> + 'd,
-        a: impl Unborrow<Target = impl GpioPin> + 'd,
-        b: impl Unborrow<Target = impl GpioPin> + 'd,
+        qdec: impl Peripheral<P = QDEC> + 'd,
+        irq: impl Peripheral<P = interrupt::QDEC> + 'd,
+        a: impl Peripheral<P = impl GpioPin> + 'd,
+        b: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(a, b);
-        Self::new_inner(qdec, irq, a.degrade(), b.degrade(), None, config)
+        into_ref!(a, b);
+        Self::new_inner(qdec, irq, a.map_into(), b.map_into(), None, config)
     }
 
     pub fn new_with_led(
-        qdec: impl Unborrow<Target = QDEC> + 'd,
-        irq: impl Unborrow<Target = interrupt::QDEC> + 'd,
-        a: impl Unborrow<Target = impl GpioPin> + 'd,
-        b: impl Unborrow<Target = impl GpioPin> + 'd,
-        led: impl Unborrow<Target = impl GpioPin> + 'd,
+        qdec: impl Peripheral<P = QDEC> + 'd,
+        irq: impl Peripheral<P = interrupt::QDEC> + 'd,
+        a: impl Peripheral<P = impl GpioPin> + 'd,
+        b: impl Peripheral<P = impl GpioPin> + 'd,
+        led: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(a, b, led);
-        Self::new_inner(qdec, irq, a.degrade(), b.degrade(), Some(led.degrade()), config)
+        into_ref!(a, b, led);
+        Self::new_inner(qdec, irq, a.map_into(), b.map_into(), Some(led.map_into()), config)
     }
 
     fn new_inner(
-        _t: impl Unborrow<Target = QDEC> + 'd,
-        irq: impl Unborrow<Target = interrupt::QDEC> + 'd,
-        a: AnyPin,
-        b: AnyPin,
-        led: Option<AnyPin>,
+        p: impl Peripheral<P = QDEC> + 'd,
+        irq: impl Peripheral<P = interrupt::QDEC> + 'd,
+        a: PeripheralRef<'d, AnyPin>,
+        b: PeripheralRef<'d, AnyPin>,
+        led: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(p, irq);
         let r = Self::regs();
 
         // Select pins.
@@ -131,7 +130,7 @@ impl<'d> Qdec<'d> {
         });
         irq.enable();
 
-        Self { phantom: PhantomData }
+        Self { _p: p }
     }
 
     /// Perform an asynchronous read of the decoder.
diff --git a/embassy-nrf/src/qspi.rs b/embassy-nrf/src/qspi.rs
index 92fa79b8a..67634b5b7 100644
--- a/embassy-nrf/src/qspi.rs
+++ b/embassy-nrf/src/qspi.rs
@@ -1,20 +1,18 @@
 #![macro_use]
 
-use core::marker::PhantomData;
 use core::ptr;
 use core::task::Poll;
 
 use embassy_hal_common::drop::DropBomb;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 
-use crate::gpio::sealed::Pin as _;
 use crate::gpio::{self, Pin as GpioPin};
 use crate::interrupt::{Interrupt, InterruptExt};
 pub use crate::pac::qspi::ifconfig0::{
     ADDRMODE_A as AddressMode, PPSIZE_A as WritePageSize, READOC_A as ReadOpcode, WRITEOC_A as WriteOpcode,
 };
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 // TODO
 // - config:
@@ -63,38 +61,38 @@ pub enum Error {
 }
 
 pub struct Qspi<'d, T: Instance, const FLASH_SIZE: usize> {
-    irq: T::Interrupt,
+    irq: PeripheralRef<'d, T::Interrupt>,
     dpm_enabled: bool,
-    phantom: PhantomData<&'d mut T>,
 }
 
 impl<'d, T: Instance, const FLASH_SIZE: usize> Qspi<'d, T, FLASH_SIZE> {
     pub fn new(
-        _qspi: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sck: impl Unborrow<Target = impl GpioPin> + 'd,
-        csn: impl Unborrow<Target = impl GpioPin> + 'd,
-        io0: impl Unborrow<Target = impl GpioPin> + 'd,
-        io1: impl Unborrow<Target = impl GpioPin> + 'd,
-        io2: impl Unborrow<Target = impl GpioPin> + 'd,
-        io3: impl Unborrow<Target = impl GpioPin> + 'd,
+        _qspi: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sck: impl Peripheral<P = impl GpioPin> + 'd,
+        csn: impl Peripheral<P = impl GpioPin> + 'd,
+        io0: impl Peripheral<P = impl GpioPin> + 'd,
+        io1: impl Peripheral<P = impl GpioPin> + 'd,
+        io2: impl Peripheral<P = impl GpioPin> + 'd,
+        io3: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Qspi<'d, T, FLASH_SIZE> {
-        unborrow!(irq, sck, csn, io0, io1, io2, io3);
+        into_ref!(irq, sck, csn, io0, io1, io2, io3);
 
         let r = T::regs();
 
-        let sck = sck.degrade();
-        let csn = csn.degrade();
-        let io0 = io0.degrade();
-        let io1 = io1.degrade();
-        let io2 = io2.degrade();
-        let io3 = io3.degrade();
-
-        for pin in [&sck, &csn, &io0, &io1, &io2, &io3] {
-            pin.set_high();
-            pin.conf().write(|w| w.dir().output().drive().h0h1());
-        }
+        sck.set_high();
+        csn.set_high();
+        io0.set_high();
+        io1.set_high();
+        io2.set_high();
+        io3.set_high();
+        sck.conf().write(|w| w.dir().output().drive().h0h1());
+        csn.conf().write(|w| w.dir().output().drive().h0h1());
+        io0.conf().write(|w| w.dir().output().drive().h0h1());
+        io1.conf().write(|w| w.dir().output().drive().h0h1());
+        io2.conf().write(|w| w.dir().output().drive().h0h1());
+        io3.conf().write(|w| w.dir().output().drive().h0h1());
 
         r.psel.sck.write(|w| unsafe { w.bits(sck.psel_bits()) });
         r.psel.csn.write(|w| unsafe { w.bits(csn.psel_bits()) });
@@ -143,7 +141,6 @@ impl<'d, T: Instance, const FLASH_SIZE: usize> Qspi<'d, T, FLASH_SIZE> {
         let mut res = Self {
             dpm_enabled: config.deep_power_down.is_some(),
             irq,
-            phantom: PhantomData,
         };
 
         r.events_ready.reset();
@@ -536,7 +533,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static {
     type Interrupt: Interrupt;
 }
 
diff --git a/embassy-nrf/src/rng.rs b/embassy-nrf/src/rng.rs
index e68ed912e..9bebd6fa3 100644
--- a/embassy-nrf/src/rng.rs
+++ b/embassy-nrf/src/rng.rs
@@ -1,16 +1,15 @@
-use core::marker::PhantomData;
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 use core::task::Poll;
 
 use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 
 use crate::interrupt::InterruptExt;
 use crate::peripherals::RNG;
-use crate::{interrupt, pac, Unborrow};
+use crate::{interrupt, pac, Peripheral};
 
 impl RNG {
     fn regs() -> &'static pac::rng::RegisterBlock {
@@ -34,8 +33,7 @@ struct State {
 ///
 /// It has a non-blocking API, and a blocking api through `rand`.
 pub struct Rng<'d> {
-    irq: interrupt::RNG,
-    phantom: PhantomData<(&'d mut RNG, &'d mut interrupt::RNG)>,
+    irq: PeripheralRef<'d, interrupt::RNG>,
 }
 
 impl<'d> Rng<'d> {
@@ -45,13 +43,10 @@ impl<'d> Rng<'d> {
     /// e.g. using `mem::forget`.
     ///
     /// The synchronous API is safe.
-    pub fn new(_rng: impl Unborrow<Target = RNG> + 'd, irq: impl Unborrow<Target = interrupt::RNG> + 'd) -> Self {
-        unborrow!(irq);
+    pub fn new(_rng: impl Peripheral<P = RNG> + 'd, irq: impl Peripheral<P = interrupt::RNG> + 'd) -> Self {
+        into_ref!(irq);
 
-        let this = Self {
-            irq,
-            phantom: PhantomData,
-        };
+        let this = Self { irq };
 
         this.stop();
         this.disable_irq();
diff --git a/embassy-nrf/src/saadc.rs b/embassy-nrf/src/saadc.rs
index af1aa8812..6ddc70e52 100644
--- a/embassy-nrf/src/saadc.rs
+++ b/embassy-nrf/src/saadc.rs
@@ -1,11 +1,10 @@
 #![macro_use]
 
-use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy::waitqueue::AtomicWaker;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
 use futures::future::poll_fn;
 use pac::{saadc, SAADC};
 use saadc::ch::config::{GAIN_A, REFSEL_A, RESP_A, TACQ_A};
@@ -14,10 +13,11 @@ pub(crate) use saadc::ch::pselp::PSELP_A as InputChannel;
 use saadc::oversample::OVERSAMPLE_A;
 use saadc::resolution::VAL_A;
 
+use self::sealed::Input as _;
 use crate::interrupt::InterruptExt;
 use crate::ppi::{ConfigurableChannel, Event, Ppi, Task};
 use crate::timer::{Frequency, Instance as TimerInstance, Timer};
-use crate::{interrupt, pac, peripherals, Unborrow};
+use crate::{interrupt, pac, peripherals, Peripheral};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -26,7 +26,7 @@ pub enum Error {}
 
 /// One-shot and continuous SAADC.
 pub struct Saadc<'d, const N: usize> {
-    phantom: PhantomData<&'d mut peripherals::SAADC>,
+    _p: PeripheralRef<'d, peripherals::SAADC>,
 }
 
 static WAKER: AtomicWaker = AtomicWaker::new();
@@ -66,106 +66,37 @@ pub struct ChannelConfig<'d> {
     /// Acquisition time in microseconds.
     pub time: Time,
     /// Positive channel to sample
-    p_channel: InputChannel,
+    p_channel: PeripheralRef<'d, AnyInput>,
     /// An optional negative channel to sample
-    n_channel: Option<InputChannel>,
-
-    phantom: PhantomData<&'d ()>,
-}
-
-/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
-/// internal voltage.
-pub struct VddInput;
-
-unsafe impl Unborrow for VddInput {
-    type Target = VddInput;
-    unsafe fn unborrow(self) -> Self::Target {
-        self
-    }
-}
-
-impl sealed::Input for VddInput {
-    #[cfg(not(feature = "_nrf9160"))]
-    fn channel(&self) -> InputChannel {
-        InputChannel::VDD
-    }
-    #[cfg(feature = "_nrf9160")]
-    fn channel(&self) -> InputChannel {
-        InputChannel::VDDGPIO
-    }
-}
-impl Input for VddInput {}
-
-/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
-/// VDDH / 5 voltage.
-#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
-pub struct VddhDiv5Input;
-
-#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
-unsafe impl Unborrow for VddhDiv5Input {
-    type Target = VddhDiv5Input;
-    unsafe fn unborrow(self) -> Self::Target {
-        self
-    }
-}
-
-#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
-impl sealed::Input for VddhDiv5Input {
-    fn channel(&self) -> InputChannel {
-        InputChannel::VDDHDIV5
-    }
-}
-
-#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
-impl Input for VddhDiv5Input {}
-
-pub struct AnyInput {
-    channel: InputChannel,
-}
-
-unsafe impl Unborrow for AnyInput {
-    type Target = AnyInput;
-    unsafe fn unborrow(self) -> Self::Target {
-        self
-    }
-}
-
-impl sealed::Input for AnyInput {
-    fn channel(&self) -> InputChannel {
-        self.channel
-    }
+    n_channel: Option<PeripheralRef<'d, AnyInput>>,
 }
 
-impl Input for AnyInput {}
-
 impl<'d> ChannelConfig<'d> {
     /// Default configuration for single ended channel sampling.
-    pub fn single_ended(input: impl Unborrow<Target = impl Input> + 'd) -> Self {
-        unborrow!(input);
+    pub fn single_ended(input: impl Peripheral<P = impl Input> + 'd) -> Self {
+        into_ref!(input);
         Self {
             reference: Reference::INTERNAL,
             gain: Gain::GAIN1_6,
             resistor: Resistor::BYPASS,
             time: Time::_10US,
-            p_channel: input.channel(),
+            p_channel: input.map_into(),
             n_channel: None,
-            phantom: PhantomData,
         }
     }
     /// Default configuration for differential channel sampling.
     pub fn differential(
-        p_input: impl Unborrow<Target = impl Input> + 'd,
-        n_input: impl Unborrow<Target = impl Input> + 'd,
+        p_input: impl Peripheral<P = impl Input> + 'd,
+        n_input: impl Peripheral<P = impl Input> + 'd,
     ) -> Self {
-        unborrow!(p_input, n_input);
+        into_ref!(p_input, n_input);
         Self {
             reference: Reference::INTERNAL,
             gain: Gain::GAIN1_6,
             resistor: Resistor::BYPASS,
             time: Time::_10US,
-            p_channel: p_input.channel(),
-            n_channel: Some(n_input.channel()),
-            phantom: PhantomData,
+            p_channel: p_input.map_into(),
+            n_channel: Some(n_input.map_into()),
         }
     }
 }
@@ -182,12 +113,12 @@ pub enum SamplerState {
 
 impl<'d, const N: usize> Saadc<'d, N> {
     pub fn new(
-        _saadc: impl Unborrow<Target = peripherals::SAADC> + 'd,
-        irq: impl Unborrow<Target = interrupt::SAADC> + 'd,
+        saadc: impl Peripheral<P = peripherals::SAADC> + 'd,
+        irq: impl Peripheral<P = interrupt::SAADC> + 'd,
         config: Config,
         channel_configs: [ChannelConfig; N],
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(saadc, irq);
 
         let r = unsafe { &*SAADC::ptr() };
 
@@ -199,9 +130,11 @@ impl<'d, const N: usize> Saadc<'d, N> {
         r.oversample.write(|w| w.oversample().variant(oversample.into()));
 
         for (i, cc) in channel_configs.iter().enumerate() {
-            r.ch[i].pselp.write(|w| w.pselp().variant(cc.p_channel));
-            if let Some(n_channel) = cc.n_channel {
-                r.ch[i].pseln.write(|w| unsafe { w.pseln().bits(n_channel as u8) });
+            r.ch[i].pselp.write(|w| w.pselp().variant(cc.p_channel.channel()));
+            if let Some(n_channel) = &cc.n_channel {
+                r.ch[i]
+                    .pseln
+                    .write(|w| unsafe { w.pseln().bits(n_channel.channel() as u8) });
             }
             r.ch[i].config.write(|w| {
                 w.refsel().variant(cc.reference.into());
@@ -230,7 +163,7 @@ impl<'d, const N: usize> Saadc<'d, N> {
         irq.unpend();
         irq.enable();
 
-        Self { phantom: PhantomData }
+        Self { _p: saadc }
     }
 
     fn on_interrupt(_ctx: *mut ()) {
@@ -689,7 +622,7 @@ pub(crate) mod sealed {
 }
 
 /// An input that can be used as either or negative end of a ADC differential in the SAADC periperhal.
-pub trait Input: sealed::Input + Unborrow<Target = Self> + Sized {
+pub trait Input: sealed::Input + Into<AnyInput> + Peripheral<P = Self> + Sized + 'static {
     fn degrade_saadc(self) -> AnyInput {
         AnyInput {
             channel: self.channel(),
@@ -697,13 +630,57 @@ pub trait Input: sealed::Input + Unborrow<Target = Self> + Sized {
     }
 }
 
+pub struct AnyInput {
+    channel: InputChannel,
+}
+
+impl_peripheral!(AnyInput);
+
+impl sealed::Input for AnyInput {
+    fn channel(&self) -> InputChannel {
+        self.channel
+    }
+}
+
+impl Input for AnyInput {}
+
 macro_rules! impl_saadc_input {
     ($pin:ident, $ch:ident) => {
-        impl crate::saadc::sealed::Input for crate::peripherals::$pin {
+        impl_saadc_input!(@local, crate::peripherals::$pin, $ch);
+    };
+    (@local, $pin:ty, $ch:ident) => {
+        impl crate::saadc::sealed::Input for $pin {
             fn channel(&self) -> crate::saadc::InputChannel {
                 crate::saadc::InputChannel::$ch
             }
         }
-        impl crate::saadc::Input for crate::peripherals::$pin {}
+        impl crate::saadc::Input for $pin {}
+
+        impl From<$pin> for crate::saadc::AnyInput {
+            fn from(val: $pin) -> Self {
+                crate::saadc::Input::degrade_saadc(val)
+            }
+        }
     };
 }
+
+/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
+/// internal voltage.
+pub struct VddInput;
+
+impl_peripheral!(VddInput);
+#[cfg(not(feature = "_nrf9160"))]
+impl_saadc_input!(@local, VddInput, VDD);
+#[cfg(feature = "_nrf9160")]
+impl_saadc_input!(@local, VddInput, VDDGPIO);
+
+/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
+/// VDDH / 5 voltage.
+#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
+pub struct VddhDiv5Input;
+
+#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
+impl_peripheral!(VddhDiv5Input);
+
+#[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
+impl_saadc_input!(@local, VddhDiv5Input, VDDHDIV5);
diff --git a/embassy-nrf/src/spim.rs b/embassy-nrf/src/spim.rs
index d34d9a0c8..a512b4813 100644
--- a/embassy-nrf/src/spim.rs
+++ b/embassy-nrf/src/spim.rs
@@ -1,11 +1,10 @@
 #![macro_use]
 
-use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 pub use embedded_hal_02::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};
 use futures::future::poll_fn;
 pub use pac::spim0::frequency::FREQUENCY_A as Frequency;
@@ -15,7 +14,7 @@ use crate::gpio::sealed::Pin as _;
 use crate::gpio::{self, AnyPin, Pin as GpioPin, PselBits};
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::util::{slice_in_ram_or, slice_ptr_parts, slice_ptr_parts_mut};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -31,7 +30,7 @@ pub enum Error {
 ///
 /// For more details about EasyDMA, consult the module documentation.
 pub struct Spim<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
 }
 
 #[non_exhaustive]
@@ -53,55 +52,55 @@ impl Default for Config {
 
 impl<'d, T: Instance> Spim<'d, T> {
     pub fn new(
-        spim: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sck: impl Unborrow<Target = impl GpioPin> + 'd,
-        miso: impl Unborrow<Target = impl GpioPin> + 'd,
-        mosi: impl Unborrow<Target = impl GpioPin> + 'd,
+        spim: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sck: impl Peripheral<P = impl GpioPin> + 'd,
+        miso: impl Peripheral<P = impl GpioPin> + 'd,
+        mosi: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(sck, miso, mosi);
+        into_ref!(sck, miso, mosi);
         Self::new_inner(
             spim,
             irq,
-            sck.degrade(),
-            Some(miso.degrade()),
-            Some(mosi.degrade()),
+            sck.map_into(),
+            Some(miso.map_into()),
+            Some(mosi.map_into()),
             config,
         )
     }
 
     pub fn new_txonly(
-        spim: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sck: impl Unborrow<Target = impl GpioPin> + 'd,
-        mosi: impl Unborrow<Target = impl GpioPin> + 'd,
+        spim: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sck: impl Peripheral<P = impl GpioPin> + 'd,
+        mosi: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(sck, mosi);
-        Self::new_inner(spim, irq, sck.degrade(), None, Some(mosi.degrade()), config)
+        into_ref!(sck, mosi);
+        Self::new_inner(spim, irq, sck.map_into(), None, Some(mosi.map_into()), config)
     }
 
     pub fn new_rxonly(
-        spim: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sck: impl Unborrow<Target = impl GpioPin> + 'd,
-        miso: impl Unborrow<Target = impl GpioPin> + 'd,
+        spim: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sck: impl Peripheral<P = impl GpioPin> + 'd,
+        miso: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(sck, miso);
-        Self::new_inner(spim, irq, sck.degrade(), Some(miso.degrade()), None, config)
+        into_ref!(sck, miso);
+        Self::new_inner(spim, irq, sck.map_into(), Some(miso.map_into()), None, config)
     }
 
     fn new_inner(
-        _spim: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sck: AnyPin,
-        miso: Option<AnyPin>,
-        mosi: Option<AnyPin>,
+        spim: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sck: PeripheralRef<'d, AnyPin>,
+        miso: Option<PeripheralRef<'d, AnyPin>>,
+        mosi: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(spim, irq);
 
         let r = T::regs();
 
@@ -181,7 +180,7 @@ impl<'d, T: Instance> Spim<'d, T> {
         irq.unpend();
         irq.enable();
 
-        Self { phantom: PhantomData }
+        Self { _p: spim }
     }
 
     fn on_interrupt(_: *mut ()) {
@@ -386,7 +385,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static {
     type Interrupt: Interrupt;
 }
 
diff --git a/embassy-nrf/src/temp.rs b/embassy-nrf/src/temp.rs
index 43ba3e042..a3b25ce05 100644
--- a/embassy-nrf/src/temp.rs
+++ b/embassy-nrf/src/temp.rs
@@ -1,29 +1,27 @@
 //! Temperature sensor interface.
 
-use core::marker::PhantomData;
 use core::task::Poll;
 
 use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use fixed::types::I30F2;
 use futures::future::poll_fn;
 
 use crate::interrupt::InterruptExt;
 use crate::peripherals::TEMP;
-use crate::{interrupt, pac, Unborrow};
+use crate::{interrupt, pac, Peripheral};
 
 /// Integrated temperature sensor.
 pub struct Temp<'d> {
-    _temp: PhantomData<&'d TEMP>,
-    _irq: interrupt::TEMP,
+    _irq: PeripheralRef<'d, interrupt::TEMP>,
 }
 
 static WAKER: AtomicWaker = AtomicWaker::new();
 
 impl<'d> Temp<'d> {
-    pub fn new(_t: impl Unborrow<Target = TEMP> + 'd, irq: impl Unborrow<Target = interrupt::TEMP> + 'd) -> Self {
-        unborrow!(_t, irq);
+    pub fn new(_t: impl Peripheral<P = TEMP> + 'd, irq: impl Peripheral<P = interrupt::TEMP> + 'd) -> Self {
+        into_ref!(_t, irq);
 
         // Enable interrupt that signals temperature values
         irq.disable();
@@ -33,10 +31,7 @@ impl<'d> Temp<'d> {
             WAKER.wake();
         });
         irq.enable();
-        Self {
-            _temp: PhantomData,
-            _irq: irq,
-        }
+        Self { _irq: irq }
     }
 
     /// Perform an asynchronous temperature measurement. The returned future
diff --git a/embassy-nrf/src/timer.rs b/embassy-nrf/src/timer.rs
index c8c36dfae..8deecdc03 100644
--- a/embassy-nrf/src/timer.rs
+++ b/embassy-nrf/src/timer.rs
@@ -5,12 +5,12 @@ use core::task::Poll;
 
 use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::ppi::{Event, Task};
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 pub(crate) mod sealed {
 
@@ -28,7 +28,7 @@ pub(crate) mod sealed {
     pub trait TimerType {}
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static + Send {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static + Send {
     type Interrupt: Interrupt;
 }
 pub trait ExtendedInstance: Instance + sealed::ExtendedInstance {}
@@ -95,15 +95,13 @@ impl TimerType for Awaitable {}
 impl TimerType for NotAwaitable {}
 
 pub struct Timer<'d, T: Instance, I: TimerType = NotAwaitable> {
-    phantom: PhantomData<(&'d mut T, I)>,
+    _p: PeripheralRef<'d, T>,
+    _i: PhantomData<I>,
 }
 
 impl<'d, T: Instance> Timer<'d, T, Awaitable> {
-    pub fn new_awaitable(
-        timer: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-    ) -> Self {
-        unborrow!(irq);
+    pub fn new_awaitable(timer: impl Peripheral<P = T> + 'd, irq: impl Peripheral<P = T::Interrupt> + 'd) -> Self {
+        into_ref!(irq);
 
         irq.set_handler(Self::on_interrupt);
         irq.unpend();
@@ -117,7 +115,7 @@ impl<'d, T: Instance> Timer<'d, T, NotAwaitable> {
     ///
     /// This can be useful for triggering tasks via PPI
     /// `Uarte` uses this internally.
-    pub fn new(timer: impl Unborrow<Target = T> + 'd) -> Self {
+    pub fn new(timer: impl Peripheral<P = T> + 'd) -> Self {
         Self::new_irqless(timer)
     }
 }
@@ -126,10 +124,15 @@ impl<'d, T: Instance, I: TimerType> Timer<'d, T, I> {
     /// Create a `Timer` without an interrupt, meaning `Cc::wait` won't work.
     ///
     /// This is used by the public constructors.
-    fn new_irqless(_timer: impl Unborrow<Target = T> + 'd) -> Self {
+    fn new_irqless(timer: impl Peripheral<P = T> + 'd) -> Self {
+        into_ref!(timer);
+
         let regs = T::regs();
 
-        let mut this = Self { phantom: PhantomData };
+        let mut this = Self {
+            _p: timer,
+            _i: PhantomData,
+        };
 
         // Stop the timer before doing anything else,
         // since changing BITMODE while running can cause 'unpredictable behaviour' according to the specification.
@@ -233,7 +236,8 @@ impl<'d, T: Instance, I: TimerType> Timer<'d, T, I> {
         }
         Cc {
             n,
-            phantom: PhantomData,
+            _p: self._p.reborrow(),
+            _i: PhantomData,
         }
     }
 }
@@ -245,12 +249,13 @@ impl<'d, T: Instance, I: TimerType> Timer<'d, T, I> {
 ///
 /// The timer will fire the register's COMPARE event when its counter reaches the value stored in the register.
 /// When the register's CAPTURE task is triggered, the timer will store the current value of its counter in the register
-pub struct Cc<'a, T: Instance, I: TimerType = NotAwaitable> {
+pub struct Cc<'d, T: Instance, I: TimerType = NotAwaitable> {
     n: usize,
-    phantom: PhantomData<(&'a mut T, I)>,
+    _p: PeripheralRef<'d, T>,
+    _i: PhantomData<I>,
 }
 
-impl<'a, T: Instance> Cc<'a, T, Awaitable> {
+impl<'d, T: Instance> Cc<'d, T, Awaitable> {
     /// Wait until the timer's counter reaches the value stored in this register.
     ///
     /// This requires a mutable reference so that this task's waker cannot be overwritten by a second call to `wait`.
@@ -284,9 +289,9 @@ impl<'a, T: Instance> Cc<'a, T, Awaitable> {
         on_drop.defuse();
     }
 }
-impl<'a, T: Instance> Cc<'a, T, NotAwaitable> {}
+impl<'d, T: Instance> Cc<'d, T, NotAwaitable> {}
 
-impl<'a, T: Instance, I: TimerType> Cc<'a, T, I> {
+impl<'d, T: Instance, I: TimerType> Cc<'d, T, I> {
     /// Get the current value stored in the register.
     pub fn read(&self) -> u32 {
         T::regs().cc[self.n].read().cc().bits()
diff --git a/embassy-nrf/src/twim.rs b/embassy-nrf/src/twim.rs
index 2088691b2..6d6eb84e7 100644
--- a/embassy-nrf/src/twim.rs
+++ b/embassy-nrf/src/twim.rs
@@ -7,7 +7,6 @@
 //! - nRF52832: Section 33
 //! - nRF52840: Section 6.31
 use core::future::Future;
-use core::marker::PhantomData;
 use core::sync::atomic::compiler_fence;
 use core::sync::atomic::Ordering::SeqCst;
 use core::task::Poll;
@@ -16,14 +15,14 @@ use core::task::Poll;
 use embassy::time::{Duration, Instant};
 use embassy::waitqueue::AtomicWaker;
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 
 use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE};
 use crate::gpio::Pin as GpioPin;
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::util::{slice_in_ram, slice_in_ram_or};
-use crate::{gpio, pac, Unborrow};
+use crate::{gpio, pac, Peripheral};
 
 #[derive(Clone, Copy)]
 pub enum Frequency {
@@ -75,18 +74,18 @@ pub enum Error {
 ///
 /// For more details about EasyDMA, consult the module documentation.
 pub struct Twim<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
 }
 
 impl<'d, T: Instance> Twim<'d, T> {
     pub fn new(
-        _twim: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        sda: impl Unborrow<Target = impl GpioPin> + 'd,
-        scl: impl Unborrow<Target = impl GpioPin> + 'd,
+        twim: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        sda: impl Peripheral<P = impl GpioPin> + 'd,
+        scl: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(irq, sda, scl);
+        into_ref!(twim, irq, sda, scl);
 
         let r = T::regs();
 
@@ -136,7 +135,7 @@ impl<'d, T: Instance> Twim<'d, T> {
         irq.unpend();
         irq.enable();
 
-        Self { phantom: PhantomData }
+        Self { _p: twim }
     }
 
     fn on_interrupt(_: *mut ()) {
@@ -707,7 +706,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static {
     type Interrupt: Interrupt;
 }
 
diff --git a/embassy-nrf/src/uarte.rs b/embassy-nrf/src/uarte.rs
index 459c56c8e..792b8ecca 100644
--- a/embassy-nrf/src/uarte.rs
+++ b/embassy-nrf/src/uarte.rs
@@ -13,12 +13,11 @@
 //! memory may be used given that buffers are passed in directly to its read and write
 //! methods.
 
-use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 use futures::future::poll_fn;
 use pac::uarte0::RegisterBlock;
 // Re-export SVD variants to allow user to directly set values.
@@ -31,7 +30,7 @@ use crate::interrupt::{Interrupt, InterruptExt};
 use crate::ppi::{AnyConfigurableChannel, ConfigurableChannel, Event, Ppi, Task};
 use crate::timer::{Frequency, Instance as TimerInstance, Timer};
 use crate::util::slice_in_ram_or;
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 #[derive(Clone)]
 #[non_exhaustive]
@@ -63,7 +62,6 @@ pub enum Error {
 ///
 /// For more details about EasyDMA, consult the module documentation.
 pub struct Uarte<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
     tx: UarteTx<'d, T>,
     rx: UarteRx<'d, T>,
 }
@@ -71,60 +69,60 @@ pub struct Uarte<'d, T: Instance> {
 /// Transmitter interface to the UARTE peripheral obtained
 /// via [Uarte]::split.
 pub struct UarteTx<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
 }
 
 /// Receiver interface to the UARTE peripheral obtained
 /// via [Uarte]::split.
 pub struct UarteRx<'d, T: Instance> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
 }
 
 impl<'d, T: Instance> Uarte<'d, T> {
     /// Create a new UARTE without hardware flow control
     pub fn new(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd, txd);
-        Self::new_inner(uarte, irq, rxd.degrade(), txd.degrade(), None, None, config)
+        into_ref!(rxd, txd);
+        Self::new_inner(uarte, irq, rxd.map_into(), txd.map_into(), None, None, config)
     }
 
     /// Create a new UARTE with hardware flow control (RTS/CTS)
     pub fn new_with_rtscts(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
-        cts: impl Unborrow<Target = impl GpioPin> + 'd,
-        rts: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
+        cts: impl Peripheral<P = impl GpioPin> + 'd,
+        rts: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd, txd, cts, rts);
+        into_ref!(rxd, txd, cts, rts);
         Self::new_inner(
             uarte,
             irq,
-            rxd.degrade(),
-            txd.degrade(),
-            Some(cts.degrade()),
-            Some(rts.degrade()),
+            rxd.map_into(),
+            txd.map_into(),
+            Some(cts.map_into()),
+            Some(rts.map_into()),
             config,
         )
     }
 
     fn new_inner(
-        _uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: AnyPin,
-        txd: AnyPin,
-        cts: Option<AnyPin>,
-        rts: Option<AnyPin>,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: PeripheralRef<'d, AnyPin>,
+        txd: PeripheralRef<'d, AnyPin>,
+        cts: Option<PeripheralRef<'d, AnyPin>>,
+        rts: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(uarte, irq);
 
         let r = T::regs();
 
@@ -161,9 +159,10 @@ impl<'d, T: Instance> Uarte<'d, T> {
         s.tx_rx_refcount.store(2, Ordering::Relaxed);
 
         Self {
-            phantom: PhantomData,
-            tx: UarteTx { phantom: PhantomData },
-            rx: UarteRx { phantom: PhantomData },
+            tx: UarteTx {
+                _p: unsafe { uarte.clone_unchecked() },
+            },
+            rx: UarteRx { _p: uarte },
         }
     }
 
@@ -245,35 +244,35 @@ fn configure(r: &RegisterBlock, config: Config, hardware_flow_control: bool) {
 impl<'d, T: Instance> UarteTx<'d, T> {
     /// Create a new tx-only UARTE without hardware flow control
     pub fn new(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(txd);
-        Self::new_inner(uarte, irq, txd.degrade(), None, config)
+        into_ref!(txd);
+        Self::new_inner(uarte, irq, txd.map_into(), None, config)
     }
 
     /// Create a new tx-only UARTE with hardware flow control (RTS/CTS)
     pub fn new_with_rtscts(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
-        cts: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
+        cts: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(txd, cts);
-        Self::new_inner(uarte, irq, txd.degrade(), Some(cts.degrade()), config)
+        into_ref!(txd, cts);
+        Self::new_inner(uarte, irq, txd.map_into(), Some(cts.map_into()), config)
     }
 
     fn new_inner(
-        _uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        txd: AnyPin,
-        cts: Option<AnyPin>,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        txd: PeripheralRef<'d, AnyPin>,
+        cts: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(uarte, irq);
 
         let r = T::regs();
 
@@ -299,7 +298,7 @@ impl<'d, T: Instance> UarteTx<'d, T> {
         let s = T::state();
         s.tx_rx_refcount.store(1, Ordering::Relaxed);
 
-        Self { phantom: PhantomData }
+        Self { _p: uarte }
     }
 
     pub async fn write(&mut self, buffer: &[u8]) -> Result<(), Error> {
@@ -437,35 +436,35 @@ impl<'a, T: Instance> Drop for UarteTx<'a, T> {
 impl<'d, T: Instance> UarteRx<'d, T> {
     /// Create a new rx-only UARTE without hardware flow control
     pub fn new(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd);
-        Self::new_inner(uarte, irq, rxd.degrade(), None, config)
+        into_ref!(rxd);
+        Self::new_inner(uarte, irq, rxd.map_into(), None, config)
     }
 
     /// Create a new rx-only UARTE with hardware flow control (RTS/CTS)
     pub fn new_with_rtscts(
-        uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        rts: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        rts: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd, rts);
-        Self::new_inner(uarte, irq, rxd.degrade(), Some(rts.degrade()), config)
+        into_ref!(rxd, rts);
+        Self::new_inner(uarte, irq, rxd.map_into(), Some(rts.map_into()), config)
     }
 
     fn new_inner(
-        _uarte: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        rxd: AnyPin,
-        rts: Option<AnyPin>,
+        uarte: impl Peripheral<P = T> + 'd,
+        irq: impl Peripheral<P = T::Interrupt> + 'd,
+        rxd: PeripheralRef<'d, AnyPin>,
+        rts: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
-        unborrow!(irq);
+        into_ref!(uarte, irq);
 
         let r = T::regs();
 
@@ -491,7 +490,7 @@ impl<'d, T: Instance> UarteRx<'d, T> {
         let s = T::state();
         s.tx_rx_refcount.store(1, Ordering::Relaxed);
 
-        Self { phantom: PhantomData }
+        Self { _p: uarte }
     }
 
     pub async fn read(&mut self, buffer: &mut [u8]) -> Result<(), Error> {
@@ -676,24 +675,24 @@ pub struct UarteWithIdle<'d, U: Instance, T: TimerInstance> {
 impl<'d, U: Instance, T: TimerInstance> UarteWithIdle<'d, U, T> {
     /// Create a new UARTE without hardware flow control
     pub fn new(
-        uarte: impl Unborrow<Target = U> + 'd,
-        timer: impl Unborrow<Target = T> + 'd,
-        ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        ppi_ch2: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        irq: impl Unborrow<Target = U::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = U> + 'd,
+        timer: impl Peripheral<P = T> + 'd,
+        ppi_ch1: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        ppi_ch2: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        irq: impl Peripheral<P = U::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd, txd);
+        into_ref!(rxd, txd);
         Self::new_inner(
             uarte,
             timer,
             ppi_ch1,
             ppi_ch2,
             irq,
-            rxd.degrade(),
-            txd.degrade(),
+            rxd.map_into(),
+            txd.map_into(),
             None,
             None,
             config,
@@ -702,42 +701,42 @@ impl<'d, U: Instance, T: TimerInstance> UarteWithIdle<'d, U, T> {
 
     /// Create a new UARTE with hardware flow control (RTS/CTS)
     pub fn new_with_rtscts(
-        uarte: impl Unborrow<Target = U> + 'd,
-        timer: impl Unborrow<Target = T> + 'd,
-        ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        ppi_ch2: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        irq: impl Unborrow<Target = U::Interrupt> + 'd,
-        rxd: impl Unborrow<Target = impl GpioPin> + 'd,
-        txd: impl Unborrow<Target = impl GpioPin> + 'd,
-        cts: impl Unborrow<Target = impl GpioPin> + 'd,
-        rts: impl Unborrow<Target = impl GpioPin> + 'd,
+        uarte: impl Peripheral<P = U> + 'd,
+        timer: impl Peripheral<P = T> + 'd,
+        ppi_ch1: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        ppi_ch2: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        irq: impl Peripheral<P = U::Interrupt> + 'd,
+        rxd: impl Peripheral<P = impl GpioPin> + 'd,
+        txd: impl Peripheral<P = impl GpioPin> + 'd,
+        cts: impl Peripheral<P = impl GpioPin> + 'd,
+        rts: impl Peripheral<P = impl GpioPin> + 'd,
         config: Config,
     ) -> Self {
-        unborrow!(rxd, txd, cts, rts);
+        into_ref!(rxd, txd, cts, rts);
         Self::new_inner(
             uarte,
             timer,
             ppi_ch1,
             ppi_ch2,
             irq,
-            rxd.degrade(),
-            txd.degrade(),
-            Some(cts.degrade()),
-            Some(rts.degrade()),
+            rxd.map_into(),
+            txd.map_into(),
+            Some(cts.map_into()),
+            Some(rts.map_into()),
             config,
         )
     }
 
     fn new_inner(
-        uarte: impl Unborrow<Target = U> + 'd,
-        timer: impl Unborrow<Target = T> + 'd,
-        ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        ppi_ch2: impl Unborrow<Target = impl ConfigurableChannel + 'd> + 'd,
-        irq: impl Unborrow<Target = U::Interrupt> + 'd,
-        rxd: AnyPin,
-        txd: AnyPin,
-        cts: Option<AnyPin>,
-        rts: Option<AnyPin>,
+        uarte: impl Peripheral<P = U> + 'd,
+        timer: impl Peripheral<P = T> + 'd,
+        ppi_ch1: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        ppi_ch2: impl Peripheral<P = impl ConfigurableChannel + 'd> + 'd,
+        irq: impl Peripheral<P = U::Interrupt> + 'd,
+        rxd: PeripheralRef<'d, AnyPin>,
+        txd: PeripheralRef<'d, AnyPin>,
+        cts: Option<PeripheralRef<'d, AnyPin>>,
+        rts: Option<PeripheralRef<'d, AnyPin>>,
         config: Config,
     ) -> Self {
         let baudrate = config.baudrate;
@@ -745,7 +744,7 @@ impl<'d, U: Instance, T: TimerInstance> UarteWithIdle<'d, U, T> {
 
         let mut timer = Timer::new(timer);
 
-        unborrow!(ppi_ch1, ppi_ch2);
+        into_ref!(ppi_ch1, ppi_ch2);
 
         let r = U::regs();
 
@@ -763,7 +762,7 @@ impl<'d, U: Instance, T: TimerInstance> UarteWithIdle<'d, U, T> {
         timer.cc(0).short_compare_stop();
 
         let mut ppi_ch1 = Ppi::new_one_to_two(
-            ppi_ch1.degrade(),
+            ppi_ch1.map_into(),
             Event::from_reg(&r.events_rxdrdy),
             timer.task_clear(),
             timer.task_start(),
@@ -771,7 +770,7 @@ impl<'d, U: Instance, T: TimerInstance> UarteWithIdle<'d, U, T> {
         ppi_ch1.enable();
 
         let mut ppi_ch2 = Ppi::new_one_to_one(
-            ppi_ch2.degrade(),
+            ppi_ch2.map_into(),
             timer.cc(0).event_compare(),
             Task::from_reg(&r.tasks_stoprx),
         );
@@ -958,7 +957,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static + Send {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static + Send {
     type Interrupt: Interrupt;
 }
 
diff --git a/embassy-nrf/src/usb.rs b/embassy-nrf/src/usb.rs
index a039427f1..378492859 100644
--- a/embassy-nrf/src/usb.rs
+++ b/embassy-nrf/src/usb.rs
@@ -7,7 +7,7 @@ use core::task::Poll;
 
 use cortex_m::peripheral::NVIC;
 use embassy::waitqueue::AtomicWaker;
-use embassy_hal_common::unborrow;
+use embassy_hal_common::{into_ref, PeripheralRef};
 pub use embassy_usb;
 use embassy_usb::driver::{self, EndpointError, Event, Unsupported};
 use embassy_usb::types::{EndpointAddress, EndpointInfo, EndpointType, UsbDirection};
@@ -17,7 +17,7 @@ use pac::usbd::RegisterBlock;
 
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::util::slice_in_ram;
-use crate::{pac, Unborrow};
+use crate::{pac, Peripheral};
 
 const NEW_AW: AtomicWaker = AtomicWaker::new();
 static BUS_WAKER: AtomicWaker = NEW_AW;
@@ -38,7 +38,7 @@ pub trait UsbSupply {
 }
 
 pub struct Driver<'d, T: Instance, P: UsbSupply> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
     alloc_in: Allocator,
     alloc_out: Allocator,
     usb_supply: P,
@@ -166,18 +166,14 @@ impl UsbSupply for SignalledSupply {
 }
 
 impl<'d, T: Instance, P: UsbSupply> Driver<'d, T, P> {
-    pub fn new(
-        _usb: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        usb_supply: P,
-    ) -> Self {
-        unborrow!(irq);
+    pub fn new(usb: impl Peripheral<P = T> + 'd, irq: impl Peripheral<P = T::Interrupt> + 'd, usb_supply: P) -> Self {
+        into_ref!(usb, irq);
         irq.set_handler(Self::on_interrupt);
         irq.unpend();
         irq.enable();
 
         Self {
-            phantom: PhantomData,
+            _p: usb,
             alloc_in: Allocator::new(),
             alloc_out: Allocator::new(),
             usb_supply,
@@ -273,15 +269,15 @@ impl<'d, T: Instance, P: UsbSupply + 'd> driver::Driver<'d> for Driver<'d, T, P>
         }))
     }
 
-    fn start(self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
+    fn start(mut self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
         (
             Bus {
-                phantom: PhantomData,
+                _p: unsafe { self._p.clone_unchecked() },
                 power_available: false,
                 usb_supply: self.usb_supply,
             },
             ControlPipe {
-                _phantom: PhantomData,
+                _p: self._p,
                 max_packet_size: control_max_packet_size,
             },
         )
@@ -289,7 +285,7 @@ impl<'d, T: Instance, P: UsbSupply + 'd> driver::Driver<'d> for Driver<'d, T, P>
 }
 
 pub struct Bus<'d, T: Instance, P: UsbSupply> {
-    phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
     power_available: bool,
     usb_supply: P,
 }
@@ -750,7 +746,7 @@ impl<'d, T: Instance> driver::EndpointIn for Endpoint<'d, T, In> {
 }
 
 pub struct ControlPipe<'d, T: Instance> {
-    _phantom: PhantomData<&'d mut T>,
+    _p: PeripheralRef<'d, T>,
     max_packet_size: u16,
 }
 
@@ -950,7 +946,7 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static + Send {
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static + Send {
     type Interrupt: Interrupt;
 }