diff --git a/embassy-stm32/src/dma/bdma.rs b/embassy-stm32/src/dma/bdma.rs
index d956047d..1dad364b 100644
--- a/embassy-stm32/src/dma/bdma.rs
+++ b/embassy-stm32/src/dma/bdma.rs
@@ -9,7 +9,7 @@ use atomic_polyfill::AtomicUsize;
 use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
-use super::ringbuffer::{DmaCtrl, DmaRingBuffer, OverrunError};
+use super::ringbuffer::{DmaCtrl, OverrunError, ReadableDmaRingBuffer};
 use super::word::{Word, WordSize};
 use super::Dir;
 use crate::_generated::BDMA_CHANNEL_COUNT;
@@ -395,13 +395,13 @@ impl<'a, C: Channel> DmaCtrl for DmaCtrlImpl<'a, C> {
     }
 }
 
-pub struct RingBuffer<'a, C: Channel, W: Word> {
+pub struct ReadableRingBuffer<'a, C: Channel, W: Word> {
     cr: regs::Cr,
     channel: PeripheralRef<'a, C>,
-    ringbuf: DmaRingBuffer<'a, W>,
+    ringbuf: ReadableDmaRingBuffer<'a, W>,
 }
 
-impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
+impl<'a, C: Channel, W: Word> ReadableRingBuffer<'a, C, W> {
     pub unsafe fn new_read(
         channel: impl Peripheral<P = C> + 'a,
         _request: Request,
@@ -442,7 +442,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         let mut this = Self {
             channel,
             cr: w,
-            ringbuf: DmaRingBuffer::new(buffer),
+            ringbuf: ReadableDmaRingBuffer::new(buffer),
         };
         this.clear_irqs();
 
@@ -475,7 +475,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         self.ringbuf.read(DmaCtrlImpl(self.channel.reborrow()), buf)
     }
 
-    /// Read an exact number of elements from the ringbuffer.
+    /// Read an exact number of elements from the ReadableRingBuffer.
     ///
     /// Returns the remaining number of elements available for immediate reading.
     /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
@@ -513,7 +513,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         .await
     }
 
-    /// The capacity of the ringbuffer
+    /// The capacity of the ReadableRingBuffer
     pub fn cap(&self) -> usize {
         self.ringbuf.cap()
     }
@@ -550,7 +550,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
     }
 }
 
-impl<'a, C: Channel, W: Word> Drop for RingBuffer<'a, C, W> {
+impl<'a, C: Channel, W: Word> Drop for ReadableRingBuffer<'a, C, W> {
     fn drop(&mut self) {
         self.request_stop();
         while self.is_running() {}
diff --git a/embassy-stm32/src/dma/dma.rs b/embassy-stm32/src/dma/dma.rs
index 219ef2eb..9157f72d 100644
--- a/embassy-stm32/src/dma/dma.rs
+++ b/embassy-stm32/src/dma/dma.rs
@@ -7,7 +7,7 @@ use core::task::{Context, Poll, Waker};
 use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
-use super::ringbuffer::{DmaCtrl, DmaRingBuffer, OverrunError};
+use super::ringbuffer::{DmaCtrl, OverrunError, ReadableDmaRingBuffer};
 use super::word::{Word, WordSize};
 use super::Dir;
 use crate::_generated::DMA_CHANNEL_COUNT;
@@ -625,13 +625,13 @@ impl<'a, C: Channel> DmaCtrl for DmaCtrlImpl<'a, C> {
     }
 }
 
-pub struct RingBuffer<'a, C: Channel, W: Word> {
+pub struct ReadableRingBuffer<'a, C: Channel, W: Word> {
     cr: regs::Cr,
     channel: PeripheralRef<'a, C>,
-    ringbuf: DmaRingBuffer<'a, W>,
+    ringbuf: ReadableDmaRingBuffer<'a, W>,
 }
 
-impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
+impl<'a, C: Channel, W: Word> ReadableRingBuffer<'a, C, W> {
     pub unsafe fn new_read(
         channel: impl Peripheral<P = C> + 'a,
         _request: Request,
@@ -677,7 +677,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         let mut this = Self {
             channel,
             cr: w,
-            ringbuf: DmaRingBuffer::new(buffer),
+            ringbuf: ReadableDmaRingBuffer::new(buffer),
         };
         this.clear_irqs();
 
@@ -797,7 +797,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
     }
 }
 
-impl<'a, C: Channel, W: Word> Drop for RingBuffer<'a, C, W> {
+impl<'a, C: Channel, W: Word> Drop for ReadableRingBuffer<'a, C, W> {
     fn drop(&mut self) {
         self.request_stop();
         while self.is_running() {}
diff --git a/embassy-stm32/src/dma/ringbuffer.rs b/embassy-stm32/src/dma/ringbuffer.rs
index 19079397..92be3334 100644
--- a/embassy-stm32/src/dma/ringbuffer.rs
+++ b/embassy-stm32/src/dma/ringbuffer.rs
@@ -29,7 +29,7 @@ use super::word::Word;
 ///  |                          |                    |                        |
 ///  +- end --------------------+                    +- start ----------------+
 /// ```
-pub struct DmaRingBuffer<'a, W: Word> {
+pub struct ReadableDmaRingBuffer<'a, W: Word> {
     pub(crate) dma_buf: &'a mut [W],
     start: usize,
 }
@@ -51,7 +51,7 @@ pub trait DmaCtrl {
     fn reset_complete_count(&mut self) -> usize;
 }
 
-impl<'a, W: Word> DmaRingBuffer<'a, W> {
+impl<'a, W: Word> ReadableDmaRingBuffer<'a, W> {
     pub fn new(dma_buf: &'a mut [W]) -> Self {
         Self { dma_buf, start: 0 }
     }
@@ -263,7 +263,7 @@ mod tests {
     #[test]
     fn empty_and_read_not_started() {
         let mut dma_buf = [0u8; 16];
-        let ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
     }
@@ -273,7 +273,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
@@ -314,7 +314,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
@@ -349,7 +349,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
@@ -384,7 +384,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
@@ -420,7 +420,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
@@ -454,7 +454,7 @@ mod tests {
         let mut dma = TestCircularTransfer::new(16);
 
         let mut dma_buf: [u8; 16] = array::from_fn(|idx| idx as u8); // 0, 1, ..., 15
-        let mut ringbuf = DmaRingBuffer::new(&mut dma_buf);
+        let mut ringbuf = ReadableDmaRingBuffer::new(&mut dma_buf);
 
         assert_eq!(0, ringbuf.start);
         assert_eq!(16, ringbuf.cap());
diff --git a/embassy-stm32/src/usart/ringbuffered.rs b/embassy-stm32/src/usart/ringbuffered.rs
index 80261d04..71077c07 100644
--- a/embassy-stm32/src/usart/ringbuffered.rs
+++ b/embassy-stm32/src/usart/ringbuffered.rs
@@ -6,12 +6,12 @@ use embassy_hal_internal::PeripheralRef;
 use futures::future::{select, Either};
 
 use super::{clear_interrupt_flags, rdr, sr, BasicInstance, Error, UartRx};
-use crate::dma::RingBuffer;
+use crate::dma::ReadableRingBuffer;
 use crate::usart::{Regs, Sr};
 
 pub struct RingBufferedUartRx<'d, T: BasicInstance, RxDma: super::RxDma<T>> {
     _peri: PeripheralRef<'d, T>,
-    ring_buf: RingBuffer<'d, RxDma, u8>,
+    ring_buf: ReadableRingBuffer<'d, RxDma, u8>,
 }
 
 impl<'d, T: BasicInstance, RxDma: super::RxDma<T>> UartRx<'d, T, RxDma> {
@@ -24,7 +24,7 @@ impl<'d, T: BasicInstance, RxDma: super::RxDma<T>> UartRx<'d, T, RxDma> {
         let request = self.rx_dma.request();
         let opts = Default::default();
 
-        let ring_buf = unsafe { RingBuffer::new_read(self.rx_dma, request, rdr(T::regs()), dma_buf, opts) };
+        let ring_buf = unsafe { ReadableRingBuffer::new_read(self.rx_dma, request, rdr(T::regs()), dma_buf, opts) };
 
         RingBufferedUartRx {
             _peri: self._peri,