Begin work on address filtering

Author: datdenkikniet

Cargo.toml

@@ -28,6 +28,8 @@ ieee802_3_miim = "0.7"
 cortex-m = "0.7"
 log = { version = "0.4", optional = true }
 defmt = { version = "0.3", optional = true }
+bitflags = "1.3.2"
+heapless = "0.7.16"
 
 [dependencies.smoltcp]
 version = "0.8"
@@ -36,7 +38,7 @@ features = ["medium-ethernet", "proto-ipv4"]
 optional = true
 
 [features]
-default = [ "defmt" ]
+default = ["defmt"]
 device-selected = []
 fence = []
 
@@ -64,8 +66,8 @@ stm32f779 = ["stm32f7xx-hal/stm32f779", "device-selected", "fence"]
 smoltcp-phy = ["smoltcp"]
 
 # Example features
-example-nucleo-pins = [ ]
-rtic-echo-example = [ "defmt", "smoltcp-phy", "smoltcp/defmt", "smoltcp/medium-ethernet", "smoltcp/socket-tcp" ]
+example-nucleo-pins = []
+rtic-echo-example = ["defmt", "smoltcp-phy", "smoltcp/defmt", "smoltcp/medium-ethernet", "smoltcp/socket-tcp"]
 
 [dev-dependencies]
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }

src/mac/frame_filtering/control.rs

@@ -0,0 +1,31 @@
+/// The type of frame filtering that the MAC should perform
+/// on received control frames,
+#[derive(Debug, Clone)]
+
+pub enum ControlFrameFiltering {
+    /// Prevent all control frames from reaching
+    /// the application.
+    BlockAll,
+    /// Allow all control frames to reach the application,
+    /// except for PAUSE control frames.
+    NoPause,
+    /// Allow all control frames to reach the application.
+    AllowAll,
+    /// Block control frames that do not pass the
+    /// configured address filter, but allow those that do.
+    AddressFilter,
+}
+
+impl ControlFrameFiltering {
+    /// Create a new [`ControlFrameFiltering`] that filters out
+    /// all control frames.
+    pub const fn new() -> Self {
+        Self::BlockAll
+    }
+}
+
+impl Default for ControlFrameFiltering {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/mac/frame_filtering/destination.rs

@@ -0,0 +1,58 @@
+use heapless::Vec;
+
+use super::MacAddressFilter;
+
+/// The type of filtering that the MAC should apply to
+/// frames that are to be transmitted.
+#[derive(Debug, Clone)]
+pub struct DestinationAddressFiltering {
+    /// Filtering to be performed based on perfect address matches.
+    pub perfect_filtering: PerfectDestinationAddressFiltering,
+    /// Enable or disable hash table filtering for destination
+    /// addresses.
+    pub hash_table_filtering: bool,
+}
+
+impl DestinationAddressFiltering {
+    /// Create a new [`DestinationAddressFiltering`] that does
+    /// not filter any frames.
+    pub const fn new() -> Self {
+        Self {
+            perfect_filtering: PerfectDestinationAddressFiltering::new(),
+            hash_table_filtering: false,
+        }
+    }
+}
+
+impl Default for DestinationAddressFiltering {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// The type of destination address filtering that
+/// the MAC should apply to frames.
+#[derive(Debug, Clone)]
+
+pub enum PerfectDestinationAddressFiltering {
+    /// Filter frames by their Destination Address, based on
+    /// the provided addresses.
+    Normal(Vec<MacAddressFilter, 3>),
+    /// Filter frames by their Destination Address, based on
+    /// the inverse of the provided addresses.
+    Inverse(Vec<MacAddressFilter, 3>),
+}
+
+impl PerfectDestinationAddressFiltering {
+    /// Create a new [`PerfectDestinationAddressFiltering`] that filters
+    /// out all frames.
+    pub const fn new() -> Self {
+        Self::Normal(Vec::new())
+    }
+}
+
+impl Default for PerfectDestinationAddressFiltering {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/mac/frame_filtering/hash_table.rs

@@ -0,0 +1,25 @@
+#[derive(Debug, Clone)]
+/// Configuration of the hash table used by the MAC for
+/// destination address filtering.
+pub struct HashTableValue {
+    /// The low register of the hash table.
+    pub low: u32,
+    /// The high register of the hash table.
+    pub high: u32,
+}
+
+impl HashTableValue {
+    /// Create a new hash table value that filters
+    /// out all frames.
+    pub const fn new() -> Self {
+        Self { low: 0, high: 0 }
+    }
+}
+
+/// By default, the hash table is configured so that
+/// it filters out all frames.
+impl Default for HashTableValue {
+    fn default() -> Self {
+        Self::new()
+    }
+}