PARL_IO RX for ESP32-C6 / H2 (#760)

* PARL_IO RX for ESP32-C6 / H2

* Add PARL_IO RX to README.md

* Remove logger-init from PARL_IO_RX examples

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add HMAC peripheral support (#755)
 - Add multicore-aware embassy executor for Xtensa MCUs (#723).
 - Add interrupt-executor for Xtensa MCUs (#723).
+- Add PARL_IO RX driver for ESP32-C6 / ESP32-H2 (#760)
 
 ### Changed
 

esp-hal-common/src/dma/gdma.rs

@@ -298,6 +298,28 @@ macro_rules! impl_channel {
                     ret
                 }
 
+                fn has_in_descriptor_error_dscr_empty() -> bool {
+                    let dma = unsafe { &*crate::peripherals::DMA::PTR };
+
+                    #[cfg(not(any(esp32c6, esp32h2, esp32s3)))]
+                    let ret = dma.[<int_raw_ch $num>].read().in_dscr_empty().bit();
+                    #[cfg(any(esp32c6, esp32h2, esp32s3))]
+                    let ret = dma.[<in_int_raw_ch $num>].read().in_dscr_empty().bit();
+
+                    ret
+                }
+
+                fn has_in_descriptor_error_err_eof() -> bool {
+                    let dma = unsafe { &*crate::peripherals::DMA::PTR };
+
+                    #[cfg(not(any(esp32c6, esp32h2, esp32s3)))]
+                    let ret = dma.[<int_raw_ch $num>].read().in_err_eof().bit();
+                    #[cfg(any(esp32c6, esp32h2, esp32s3))]
+                    let ret = dma.[<in_int_raw_ch $num>].read().in_err_eof().bit();
+
+                    ret
+                }
+
                 fn set_in_peripheral(peripheral: u8) {
                     let dma = unsafe { &*crate::peripherals::DMA::PTR };
 

esp-hal-common/src/dma/mod.rs

@@ -294,8 +294,15 @@ pub trait RxPrivate {
 
     fn drain_buffer(&mut self, dst: &mut [u8]) -> Result<usize, DmaError>;
 
+    /// Descriptor error detected
     fn has_error(&self) -> bool;
 
+    /// ERR_DSCR_EMPTY error detected
+    fn has_dscr_empty_error(&self) -> bool;
+
+    /// ERR_EOF error detected
+    fn has_eof_error(&self) -> bool;
+
     #[cfg(feature = "async")]
     fn waker() -> &'static embassy_sync::waitqueue::AtomicWaker;
 }
@@ -554,6 +561,14 @@ where
         R::has_in_descriptor_error()
     }
 
+    fn has_dscr_empty_error(&self) -> bool {
+        R::has_in_descriptor_error_dscr_empty()
+    }
+
+    fn has_eof_error(&self) -> bool {
+        R::has_in_descriptor_error_err_eof()
+    }
+
     #[cfg(feature = "async")]
     fn waker() -> &'static embassy_sync::waitqueue::AtomicWaker {
         T::waker()
@@ -904,6 +919,8 @@ pub trait RegisterAccess {
     fn reset_in();
     fn set_in_descriptors(address: u32);
     fn has_in_descriptor_error() -> bool;
+    fn has_in_descriptor_error_dscr_empty() -> bool;
+    fn has_in_descriptor_error_err_eof() -> bool;
     fn set_in_peripheral(peripheral: u8);
     fn start_in();
     fn is_in_done() -> bool;

esp-hal-common/src/dma/pdma.rs

@@ -168,6 +168,16 @@ macro_rules! ImplSpiChannel {
                     spi.dma_int_raw.read().inlink_dscr_error_int_raw().bit()
                 }
 
+                fn has_in_descriptor_error_dscr_empty() -> bool {
+                    let spi = unsafe { &*crate::peripherals::[<SPI $num>]::PTR };
+                    spi.dma_int_raw.read().inlink_dscr_empty_int_raw().bit()
+                }
+
+                fn has_in_descriptor_error_err_eof() -> bool {
+                    let spi = unsafe { &*crate::peripherals::[<SPI $num>]::PTR };
+                    spi.dma_int_raw.read().in_err_eof_int_raw().bit()
+                }
+
                 fn set_in_peripheral(_peripheral: u8) {
                     // no-op
                 }
@@ -421,6 +431,16 @@ macro_rules! ImplI2sChannel {
                     reg_block.int_raw.read().in_dscr_err_int_raw().bit()
                 }
 
+                fn has_in_descriptor_error_dscr_empty() -> bool {
+                    let reg_block = unsafe { &*crate::peripherals::[<$peripheral>]::PTR };
+                    reg_block.int_raw.read().in_dscr_empty_int_raw().bit()
+                }
+
+                fn has_in_descriptor_error_err_eof() -> bool {
+                    let reg_block = unsafe { &*crate::peripherals::[<$peripheral>]::PTR };
+                    reg_block.int_raw.read().in_err_eof_int_raw().bit()
+                }
+
                 fn set_in_peripheral(_peripheral: u8) {
                     // no-op
                 }