Fix issues with watermark sizes

This change fixes some issues where watermark sizes were interpreted the
wrong way. Before this commit, watermarks for Rx FIFOs and Tx Event FIFO
were clamped to the maximum permissible watermark. But the behavior
according to the users manual is that watermark sizes over the
maximum permissible will disable the corresponding interrupt.

P.31 and p.34 of the M_CAN users manual v330 states that Rx FIFO
Watermarks, FnWM, can take values 1-64 inclusive. Any value greater than
64 is interpreted as "Watermark interrupt disabled".

P.44 of the M_CAN users manual v330 states that the Tx Event FIFO
Watermark, EFWM, can take values 1-32 inclusive, Any value greater than
32 is interpreted as "Watermark interrupt disabled".

This change makes the implementation consistent with the users manual on
those specifics.

A value greater than the maximum will be changed to zero for
consistency. The bit ranges are 6 bits wide for the Tx Event and
7 bits wide for the Rx configs but the u8 datatype is used in the
software interface. That u8 will be masked and shifted so that f.ex.
writing 129 to either bit range will actually set the value to 1, not
consistent with the user manual.
Clamping to any value over the maximum seems arbitrary, and for that
reason values larger than the maximum permissible are set to zero, which
also disables the interrupt.

mcan/CHANGELOG.md

@@ -3,6 +3,7 @@
 Tagging in git follows a pattern: `mcan/<version>`.
 
 ## [Unreleased]
+- Fix some issues with watermark sizes for Rx FIFOs and Tx Event FIFO.
 - Add Can::aux::initialization_mode
 - Adhere to `filter_map_bool_then` clippy lint (#42)
 

mcan/src/bus.rs

@@ -339,9 +339,10 @@ impl<'a, Id: mcan_core::CanId, D: mcan_core::Dependencies<Id>, C: Capacities>
         reg.rxf0.c.modify(|_, w| {
             let w = w.fom().bit(config.rx_fifo_0.mode.into());
             let mut watermark = config.rx_fifo_0.watermark;
-            // According to the spec, any value >= 64 is interpreted as watermark disabled
-            if watermark >= 64 {
-                watermark = 64;
+            // According to the spec, any value > 64 is interpreted as watermark interrupt
+            // disabled, as is 0.
+            if watermark > 64 {
+                watermark = 0;
             }
             // Safety: The value is sanitized before the write
             unsafe { w.fwm().bits(watermark) }
@@ -351,9 +352,10 @@ impl<'a, Id: mcan_core::CanId, D: mcan_core::Dependencies<Id>, C: Capacities>
         reg.rxf1.c.modify(|_, w| {
             let w = w.fom().bit(config.rx_fifo_1.mode.into());
             let mut watermark = config.rx_fifo_1.watermark;
-            // According to the spec, any value >= 64 is interpreted as watermark disabled
-            if watermark >= 64 {
-                watermark = 64;
+            // According to the spec, any value > 64 is interpreted as watermark interrupt
+            // disabled, as is 0.
+            if watermark > 64 {
+                watermark = 0;
             }
             // Safety: The value is sanitized before the write
             unsafe { w.fwm().bits(watermark) }
@@ -366,9 +368,10 @@ impl<'a, Id: mcan_core::CanId, D: mcan_core::Dependencies<Id>, C: Capacities>
         // Configure Tx Event Fifo
         reg.txefc.modify(|_, w| {
             let mut watermark = config.tx.tx_event_fifo_watermark;
-            // According to the spec, any value >= 32 is interpreted as watermark disabled
-            if watermark >= 32 {
-                watermark = 32;
+            // According to the spec, any value > 32 is interpreted as watermark interrupt
+            // disabled, as is 0.
+            if watermark > 32 {
+                watermark = 0;
             }
             // Safety: The value is sanitized before the write
             unsafe { w.efwm().bits(watermark) }