feat(hal): Add preliminary support for LEDC

Signed-off-by: Hanrui Li <[email protected]>

Author: lihanrui2913

allwinner-hal/src/ledc/mod.rs

@@ -0,0 +1,3 @@
+//! LED control (LEDC) peripheral.
+
+pub mod register;

allwinner-hal/src/ledc/register.rs

@@ -0,0 +1,225 @@
+use volatile_register::RW;
+
+/// LEDC Controller registers.
+#[repr(C)]
+pub struct RegisterBlock {
+    /// LEDC Control Register.
+    pub ledc_control: RW<LedcControl>,
+}
+
+/// LEDC RGB mode.
+///
+/// By default, the software configures data to LEDC according to
+/// GRB (MSB) mode, the LEDC internal combines data to output to
+/// the external LED.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[repr(u32)]
+pub enum RgbMode {
+    GRB = 0b000,
+    GBR = 0b001,
+    RGB = 0b010,
+    RBG = 0b011,
+    BGR = 0b100,
+    BRG = 0b101,
+}
+
+/// LEDC Control Register.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct LedcControl(u32);
+
+impl LedcControl {
+    /// That the bit is enabled indicates LEDC can be started when LEDC
+    /// data finished transmission or LEDC_EN is cleared to 0 by
+    /// hardware in LEDC_SOFT_RESET situation.
+    const LED_EN: u32 = 1 << 0;
+    /// Write 1 to clear it automatically.
+    /// The ranges of LEDC soft reset include the following points: all
+    /// internal status registers, the control state machine returns to in
+    /// idle status, the LEDC FIFO read & write point is cleared to 0, the
+    /// LEDC interrupt is cleared; and the affected registers are
+    /// followed.
+    const LED_SOFT_RST: u32 = 1 << 1;
+    /// MSB control for Blue data.
+    const LED_MSB_B: u32 = 1 << 2;
+    /// MSB control for Red data.
+    const LED_MSB_R: u32 = 1 << 3;
+    /// MSB control for Green data.
+    const LED_MSB_G: u32 = 1 << 4;
+    /// Adjust sequence of the combined GRB data.
+    const LED_MSB_TOP: u32 = 1 << 5;
+    /// The software writes 1 to the bit, the CPU triggers LEDC to
+    /// transfer a reset to LED.
+    /// Only when LEDC is in IDLE status, the reset can be performed.
+    /// After the reset finished, the control state machine returns to
+    /// the IDLE status. To return LEDC to the IDLE status, it also needs
+    /// to be used with SOFT_RESET.
+    /// When the software sets the bit, the software can read the bit
+    /// to check if the reset is complete.
+    const RESET_LED_EN: u32 = 1 << 10;
+
+    /// LEDC is enabled.
+    #[inline]
+    pub const fn is_enabled(self) -> bool {
+        (self.0 & Self::LED_EN) != 0
+    }
+
+    /// Set or clear LEDC enable bit.
+    #[inline]
+    pub const fn set_enable(self, enable: bool) -> Self {
+        if enable {
+            Self(self.0 | Self::LED_EN)
+        } else {
+            Self(self.0 & !Self::LED_EN)
+        }
+    }
+
+    /// Get the red LEDC MSB control bit.
+    #[inline]
+    pub const fn is_red_msb(self) -> bool {
+        (self.0 & Self::LED_MSB_R) != 0
+    }
+    /// Get the blue LEDC MSB control bit.
+    #[inline]
+    pub const fn is_blue_msb(self) -> bool {
+        (self.0 & Self::LED_MSB_B) != 0
+    }
+    /// Get the green LEDC MSB control bit.
+    #[inline]
+    pub const fn is_green_msb(self) -> bool {
+        (self.0 & Self::LED_MSB_G) != 0
+    }
+
+    /// Set or clear the red LEDC MSB control bit.
+    #[inline]
+    pub const fn set_red_msb(self, msb: bool) -> Self {
+        let mut value = self.0;
+        if msb {
+            value |= Self::LED_MSB_R;
+        } else {
+            value &= !Self::LED_MSB_R;
+        }
+        Self(value)
+    }
+    /// Set or clear the blue LEDC MSB control bit.
+    #[inline]
+    pub const fn set_blue_msb(self, msb: bool) -> Self {
+        let mut value = self.0;
+        if msb {
+            value |= Self::LED_MSB_B;
+        } else {
+            value &= !Self::LED_MSB_B;
+        }
+        Self(value)
+    }
+    /// Set or clear the green LEDC MSB control bit.
+    #[inline]
+    pub const fn set_green_msb(self, msb: bool) -> Self {
+        let mut value = self.0;
+        if msb {
+            value |= Self::LED_MSB_G;
+        } else {
+            value &= !Self::LED_MSB_G;
+        }
+        Self(value)
+    }
+
+    /// LEDC MSB_TOP control bit.
+    #[inline]
+    pub const fn is_msb_top(self) -> bool {
+        (self.0 & Self::LED_MSB_TOP) != 0
+    }
+    /// Set or clear LEDC MSB_TOP control bit.
+    #[inline]
+    pub const fn set_msb_top(self, msb_top: bool) -> Self {
+        let mut value = self.0;
+        if msb_top {
+            value |= Self::LED_MSB_TOP;
+        } else {
+            value &= !Self::LED_MSB_TOP;
+        }
+        Self(value)
+    }
+
+    /// Reset LED Enable bit status.
+    #[inline]
+    pub const fn set_reset_led_enable(self) -> Self {
+        Self(self.0 | Self::RESET_LED_EN)
+    }
+    /// Check whether reset is done.
+    #[inline]
+    pub const fn is_reset_done(self) -> bool {
+        (self.0 & Self::RESET_LED_EN) == 0
+    }
+
+    /// RGB mode selection.
+    #[inline]
+    pub const fn rgb_mode(self) -> RgbMode {
+        let raw_mode = self.0 >> 6 & 0b111;
+        match raw_mode {
+            0b000 => RgbMode::GRB,
+            0b001 => RgbMode::GBR,
+            0b010 => RgbMode::RGB,
+            0b011 => RgbMode::RBG,
+            0b100 => RgbMode::BGR,
+            0b101 => RgbMode::BRG,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Set RGB mode.
+    #[inline]
+    pub const fn set_rgb_mode(self, mode: RgbMode) -> Self {
+        // RGB mode is in bits [8:6].
+        let mut value = self.0;
+        value &= !(0b111 << 6);
+        value |= (mode as u32) << 6;
+        Self(value)
+    }
+
+    /// LEDC soft reset status.
+    #[inline]
+    pub const fn soft_reset(self) -> bool {
+        (self.0 & Self::LED_SOFT_RST) != 0
+    }
+
+    /// Clear LEDC soft reset.
+    #[inline]
+    pub const fn clear_soft_reset(self) -> Self {
+        // Write 1 to clear it.
+        Self(self.0 | Self::LED_SOFT_RST)
+    }
+
+    /// Total length of transfer data.
+    #[inline]
+    pub const fn total_data_length(self) -> u32 {
+        (self.0 >> 16) & 0xFFF
+    }
+
+    /// Set total length of transfer data.
+    #[inline]
+    pub const fn set_total_data_length(self, length: u32) -> Self {
+        let mut value = self.0;
+        value &= !(0xFFF << 16);
+        value |= (length & 0xFFF) << 16;
+        Self(value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_ledc_control_default_value() {
+        use super::{LedcControl, RgbMode};
+
+        let reg = LedcControl(0x0000_003C);
+        assert!(!reg.is_enabled());
+        assert!(!reg.soft_reset());
+        assert!(reg.is_blue_msb());
+        assert!(reg.is_red_msb());
+        assert!(reg.is_green_msb());
+        assert!(reg.is_msb_top());
+        assert_eq!(reg.rgb_mode(), RgbMode::GRB);
+        assert_eq!(reg.total_data_length(), 0);
+    }
+}

allwinner-hal/src/lib.rs

@@ -13,6 +13,7 @@ pub mod com;
 #[macro_use]
 pub mod gpio;
 pub mod dma;
+pub mod ledc;
 pub mod phy;
 pub mod smhc;
 pub mod spi;