Add Support for FlexCAN(1/2)

Cargo.toml

@@ -45,6 +45,10 @@ version = "0.2.6"
 package = "embedded-hal"
 version = "1.0.0"
 
+[dependencies.embedded_can]
+package = "embedded-can"
+version = "0.4.1"
+
 [dependencies.eio06]
 package = "embedded-io"
 version = "0.6.1"

board/src/imxrt10xx/clock_tree.rs

@@ -117,6 +117,26 @@ pub const fn lpi2c_frequency(run_mode: RunMode) -> u32 {
 
 const _: () = assert!(lpi2c_frequency(RunMode::Overdrive) == 8_000_000); // Max is 66MHz.
 
+// const fn can_divider(run_mode: RunMode) -> u32 {
+//     match run_mode {
+//         RunMode::Overdrive => 1,
+//     }
+// }
+
+// const fn can_selection(run_mode: RunMode) -> lpi2c_clk::Selection {
+//     match run_mode {
+//         RunMode::Overdrive => can_clk::Selection::Oscillator,
+//     }
+// }
+
+// /// Returns the CAN clock frequency for the run mode
+// pub const fn can_frequency(run_mode: RunMode) -> u32 {
+//     let hz = match run_mode {
+//         RunMode::Overdrive => XTAL_OSCILLATOR_HZ,
+//     };
+//     hz / can_divider(run_mode)
+// }
+
 /// Configure the PERCLK root clock.
 ///
 /// When this call returns, the PERCLK clock frequency match the values

src/chip/imxrt10xx.rs

@@ -28,6 +28,11 @@ pub(crate) mod reexports {
     pub use super::{adc, dcdc, tempmon, trng};
 }
 
+pub(crate) mod drivers {
+    #[allow(unused)] // Not entirely sure how to work around this. Could use some help here!
+    pub use super::config::drivers::*;
+}
+
 pub(crate) mod iomuxc {
     pub use super::config::pads;
     use crate::ral;

src/chip/imxrt10xx/ccm.rs

@@ -14,6 +14,17 @@ use crate::ral;
 
 pub use crate::common::ccm::XTAL_OSCILLATOR_HZ;
 
+// pub struct Handle {
+//     pub(crate) base: ral::ccm::Instance,
+//     pub(crate) analog: ral::ccm_analog::Instance,
+// }
+//
+// impl Handle {
+//     pub fn raw(&mut self) -> (&ral::ccm::Instance, &ral::ccm_analog::Instance) {
+//         (&self.base, &self.analog)
+//     }
+// }
+
 /// PERCLK clock.
 ///
 /// The PERCLK clock controls GPT and PIT timers.

src/chip/imxrt10xx/ccm/can_clk.rs

@@ -0,0 +1,52 @@
+/// CAN clock root
+use crate::ral::{self, ccm::CCM};
+
+/// Returns the can clock divider.
+#[inline(always)]
+pub fn divider(ccm: &CCM) -> u32 {
+    ral::read_reg!(ral::ccm, ccm, CSCMR2, CAN_CLK_PODF) + 1
+}
+
+/// The smallest flexcan clock divider.
+pub const MIN_DIVIDER: u32 = 1;
+/// The largest flexcan clock divider.
+pub const MAX_DIVIDER: u32 = 64;
+
+/// Set the flexcan clock divider
+#[inline(always)]
+pub fn set_divider(ccm: &mut CCM, divider: u32) {
+    let podf = divider.clamp(MIN_DIVIDER, MAX_DIVIDER) - 1;
+    ral::modify_reg!(ral::ccm, ccm, CSCMR2, CAN_CLK_PODF: podf);
+}
+
+/// Flexcan clock selections.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum Selection {
+    /// Derive from pll3_sw_clk divided clock (60M)
+    PLL3Div8 = 0,
+    /// Derive from the crystal oscillator.
+    Oscillator = 1,
+    /// Derive from pll3_sw_clk divided clock (80M)
+    PLL3Div6 = 2,
+    /// Disable flexcan clock
+    Disable = 3,
+}
+
+/// Returns the Flexcan clock selection.
+#[inline(always)]
+pub fn selection(ccm: &CCM) -> Selection {
+    match ral::read_reg!(ral::ccm, ccm, CSCMR2, CAN_CLK_SEL) {
+        0 => Selection::PLL3Div8,
+        1 => Selection::Oscillator,
+        2 => Selection::PLL3Div6,
+        3 => Selection::Disable,
+        _ => unreachable!(),
+    }
+}
+
+/// Set the Flexcan clock selection.
+#[inline(always)]
+pub fn set_selection(ccm: &mut CCM, selection: Selection) {
+    ral::modify_reg!(ral::ccm, ccm, CSCMR2, CAN_CLK_SEL: selection as u32);
+}

src/chip/imxrt10xx/ccm/clock_gate.rs

@@ -90,7 +90,7 @@ impl Setting {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[allow(unused)]
 #[repr(u8)]
-enum Register {
+pub(crate) enum Register {
     CCGR0,
     CCGR1,
     CCGR2,
@@ -107,7 +107,7 @@ use Register::*;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[allow(unused)]
 #[repr(u8)]
-enum Gate {
+pub(crate) enum Gate {
     CG0,
     CG1,
     CG2,
@@ -147,7 +147,7 @@ pub struct Locator {
     gate: Gate,
 }
 
-const fn locator(register: Register, gate: Gate) -> Locator {
+pub(crate) const fn locator(register: Register, gate: Gate) -> Locator {
     Locator { register, gate }
 }
 

src/chip/imxrt10xx/ccm/clock_gate/can.rs

@@ -0,0 +1,27 @@
+use crate::ccm::clock_gate::{locator, Gate::*, Locator, Register::*};
+use crate::ral;
+/// Returns the FlexCAN clock gate locator.
+#[inline(always)]
+pub const fn can<const N: u8>() -> Locator
+where
+    ral::can::Instance<N>: ral::Valid,
+{
+    [locator(CCGR0, CG7), locator(CCGR0, CG9)][if N == ral::SOLE_INSTANCE {
+        N as usize
+    } else {
+        N as usize - 1
+    }]
+}
+
+/// Returns the FlexCAN Peripheral Engine gate locator.
+#[inline(always)]
+pub const fn can_pe<const N: u8>() -> Locator
+where
+    ral::can::Instance<N>: ral::Valid,
+{
+    [locator(CCGR0, CG8), locator(CCGR0, CG10)][if N == ral::SOLE_INSTANCE {
+        N as usize
+    } else {
+        N as usize - 1
+    }]
+}

src/chip/imxrt10xx/drivers/can/embedded_hal.rs

@@ -0,0 +1,94 @@
+//! `embedded_hal` trait impls.
+
+use super::{Data, Error, Frame, CAN};
+
+use embedded_can;
+pub(crate) use embedded_can::ErrorKind;
+pub use embedded_can::{ExtendedId, Id, StandardId};
+
+impl<P, const M: u8> embedded_can::nb::Can for CAN<P, M> {
+    type Frame = Frame;
+
+    type Error = Error;
+
+    fn transmit(&mut self, frame: &Self::Frame) -> nb::Result<Option<Self::Frame>, Self::Error> {
+        match self.transmit(frame) {
+            Ok(_status) => Ok(Some(frame.clone())),
+            Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
+            Err(nb::Error::Other(e)) => Err(nb::Error::Other(e)),
+        }
+    }
+
+    fn receive(&mut self) -> nb::Result<Self::Frame, Self::Error> {
+        match self.read_mailboxes() {
+            Some(d) => Ok(d.frame),
+            None => Err(nb::Error::Other(Error::NoRxData)),
+        }
+    }
+}
+
+impl embedded_can::Error for Error {
+    fn kind(&self) -> embedded_can::ErrorKind {
+        match self {
+            Self::NoRxData => embedded_can::ErrorKind::Other,
+            Self::NoTxMailbox => embedded_can::ErrorKind::Other,
+            Self::EmbeddedHal(e) => e.kind(),
+        }
+    }
+}
+
+impl embedded_can::Frame for Frame {
+    fn new(id: impl Into<Id>, data: &[u8]) -> Option<Self> {
+        let id = match id.into() {
+            Id::Standard(id) => unsafe { Id::Standard(StandardId::new_unchecked(id.as_raw())) },
+            Id::Extended(id) => unsafe { Id::Extended(ExtendedId::new_unchecked(id.as_raw())) },
+        };
+
+        let data = Data::new(data)?;
+        Some(Frame::new_data(id, data))
+    }
+
+    fn new_remote(id: impl Into<Id>, dlc: usize) -> Option<Self> {
+        let id = match id.into() {
+            Id::Standard(id) => unsafe { Id::Standard(StandardId::new_unchecked(id.as_raw())) },
+            Id::Extended(id) => unsafe { Id::Extended(ExtendedId::new_unchecked(id.as_raw())) },
+        };
+
+        if dlc <= 8 {
+            Some(Frame::new_remote(id, dlc as u8))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn is_extended(&self) -> bool {
+        self.is_extended()
+    }
+
+    #[inline]
+    fn is_remote_frame(&self) -> bool {
+        self.is_remote_frame()
+    }
+
+    #[inline]
+    fn id(&self) -> Id {
+        match self.id() {
+            Id::Standard(id) => unsafe { Id::Standard(StandardId::new_unchecked(id.as_raw())) },
+            Id::Extended(id) => unsafe { Id::Extended(ExtendedId::new_unchecked(id.as_raw())) },
+        }
+    }
+
+    #[inline]
+    fn dlc(&self) -> usize {
+        self.dlc().into()
+    }
+
+    fn data(&self) -> &[u8] {
+        if let Some(data) = self.data() {
+            data
+        } else {
+            &[]
+        }
+    }
+}

src/chip/imxrt10xx/drivers/can/filter.rs

@@ -0,0 +1,54 @@
+//! Filter bank API.
+
+/// Decodes value of the ID Extended (IDE) and Remote Transmission Request (RTR) bits
+///
+/// TODO: Break this up into seperate RTR and IDE structs
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum FlexCanIde {
+    /// IDE = 0, RTR = 0
+    #[default]
+    None = 0,
+    /// IDE = 1, RTR = 0
+    Ext = 1,
+    /// IDE = 0, RTR = 1
+    Rtr = 2,
+    /// IDE = 1, RTR = 1
+    Std = 3,
+    /// Unused(?) variant
+    Inactive,
+}
+
+/// Filter enable/disable.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum FlexCanFlten {
+    /// Accept all CAN frames (filtering is disabled)
+    AcceptAll = 0,
+    /// Reject all CAN frames that do not match the filter exactly
+    #[default]
+    RejectAll = 1,
+}
+
+/// FlexCAN Filter.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub struct FlexCanFilter {
+    /// Mailbox ID that this filter will apply to
+    pub filter_id: u8,
+    /// Frame ID
+    pub id: u32,
+    /// Extended ID Bit (IDE)
+    pub ide: FlexCanIde,
+    /// Remote Frame Bit (RTR)
+    pub remote: FlexCanIde,
+}
+
+impl FlexCanFilter {
+    /// Create a new [`FlexCanFilter`].
+    pub fn new(filter_id: u8, id: u32, ide: FlexCanIde, remote: FlexCanIde) -> Self {
+        Self {
+            filter_id,
+            id,
+            ide,
+            remote,
+        }
+    }
+}