stm32: Add raw_prescaler function to make it more reusable.

This also puts the explanation why the calculation has to be done that
way into one place so it does not need to be copied all over the codebase.

Author: esden

embassy-stm32/src/adc/adc4.rs

@@ -128,8 +128,7 @@ enum Prescaler {
 
 impl Prescaler {
     fn from_ker_ck(frequency: Hertz) -> Self {
-        // Calculate prescaler in a way where the clock can hit MAX CLK
-        let raw_prescaler = frequency.0.saturating_sub(1) / MAX_ADC_CLK_FREQ.0;
+        let raw_prescaler = rcc::raw_prescaler(frequency.0 / MAX_ADC_CLK_FREQ.0);
         match raw_prescaler {
             0 => Self::NotDivided,
             1 => Self::DividedBy2,

embassy-stm32/src/adc/c0.rs

@@ -66,8 +66,7 @@ pub enum Prescaler {
 
 impl Prescaler {
     fn from_ker_ck(frequency: Hertz) -> Self {
-        // Calculate prescaler in a way where the clock can hit MAX CLK
-        let raw_prescaler = frequency.0.saturating_sub(1) / MAX_ADC_CLK_FREQ.0;
+        let raw_prescaler = rcc::raw_prescaler(frequency.0, MAX_ADC_CLK_FREQ.0);
         match raw_prescaler {
             0 => Self::NotDivided,
             1 => Self::DividedBy2,

embassy-stm32/src/adc/g4.rs

@@ -72,8 +72,7 @@ enum Prescaler {
 
 impl Prescaler {
     fn from_ker_ck(frequency: Hertz) -> Self {
-        // Calculate prescaler in a way where the clock can hit MAX CLK
-        let raw_prescaler = frequency.0.saturating_sub(1) / MAX_ADC_CLK_FREQ.0;
+        let raw_prescaler = rcc::raw_prescaler(frequency.0, MAX_ADC_CLK_FREQ.0);
         match raw_prescaler {
             0 => Self::NotDivided,
             1 => Self::DividedBy2,

embassy-stm32/src/adc/v2.rs

@@ -71,8 +71,7 @@ impl Prescaler {
         // Datasheet for both F4 and F7 specifies min frequency 0.6 MHz, typ freq. 30 MHz and max 36 MHz.
         #[cfg(not(stm32f2))]
         const MAX_FREQUENCY: Hertz = Hertz(36_000_000);
-        // Calculate prescaler divider including MAX_FREQ
-        let raw_div = freq.0.saturating_sub(1) / MAX_FREQUENCY.0;
+        let raw_div = rcc::raw_prescaler(freq.0, MAX_FREQUENCY.0);
         match raw_div {
             0..=1 => Self::Div2,
             2..=3 => Self::Div4,

embassy-stm32/src/adc/v4.rs

@@ -93,8 +93,7 @@ enum Prescaler {
 
 impl Prescaler {
     fn from_ker_ck(frequency: Hertz) -> Self {
-        // Calculate prescaler in a way where the clock can hit MAX CLK
-        let raw_prescaler = frequency.0.saturating_sub(1) / MAX_ADC_CLK_FREQ.0;
+        let raw_prescaler = rcc::raw_prescaler(frequency.0, MAX_ADC_CLK_FREQ.0);
         match raw_prescaler {
             0 => Self::NotDivided,
             1 => Self::DividedBy2,

embassy-stm32/src/rcc/mod.rs

@@ -409,3 +409,32 @@ pub(crate) fn init_rcc(_cs: CriticalSection, config: Config) {
         }
     }
 }
+
+/// Calculate intermediate prescaler number used to calculate peripheral prescalers
+///
+/// This function is intended to calculate a number indicating a minimum division
+/// necessary to result in a frequency lower than the provided `freq_max`.
+///
+/// The returned value indicates the `val + 1` divider is necessary to result in
+/// the output frequency that is below the maximum provided.
+///
+/// For example:
+/// 0 = divider of 1 => no division necessary as the input frequency is below max
+/// 1 = divider of 2 => division by 2 necessary
+/// ...
+///
+/// The provided max frequency is inclusive. So if `freq_in == freq_max` the result
+/// will be 0, indicating that no division is necessary. To accomplish that we subtract
+/// 1 from the input frequency so that the integer rounding plays in our favor.
+///
+/// For example:
+/// Let the input frequency be 110 and the max frequency be 55.
+/// If we naiively do `110/55 = 2` the renult will indicate that we need a divider by 3
+/// which in reality will be rounded up to 4 as usually a 3 division is not available.
+/// In either case the resulting frequency will be either 36 or 27 which is lower than
+/// what we would want. The result should be 1.
+/// If we do the following instead `109/55 = 1` indicating that we need a divide by 2
+/// which will result in the correct 55.
+pub(crate) fn raw_prescaler(freq_in: u32, freq_max: u32) -> u32 {
+    freq_in.saturating_sub(1) / freq_max
+}