cntrlr 0.1.0

Simple, async embedded framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2020 Branan Riley <me@branan.info>

//! PRCI
//!
///! The PRCI is responsible for generating the clocks used on the
///! FE310 series.
use super::super::Fe310G002;
use crate::{register::Register, sync::Flag};
use bit_field::BitField;
use core::{marker::PhantomData, sync::atomic::Ordering};

#[repr(C)]
struct PrciRegs {
    hfrosccfg: Register<u32>,
    hfxosccfg: Register<u32>,
    pllcfg: Register<u32>,
    plloutdiv: Register<u32>,
}

/// A PRCI
pub struct Prci<M> {
    regs: &'static mut PrciRegs,
    _mcu: PhantomData<M>,
}

static LOCK: Flag = Flag::new(false);

impl Prci<Fe310G002> {
    /// Get the PRCI instance
    pub fn get() -> Option<Self> {
        unsafe {
            if LOCK.swap(true, Ordering::Acquire) {
                None
            } else {
                Some(Self {
                    regs: &mut *(0x1000_8000 as *mut _),
                    _mcu: PhantomData,
                })
            }
        }
    }
}

impl<M> Prci<M> {
    /// Enable the PLL, with the selected set of dividers
    ///
    /// The final CPU_CLOCK will be equal to `(XTAL_IN * f) / (q * r *
    /// div)`
    ///
    /// * `r` must be in the range `1..=4`
    /// * `f` must be an even numbe in the range `2..=128`
    /// * `q` must be one of 2, 4, or 8
    /// * `div` must be 1 or be an even number in the range `2..=128`
    pub fn use_pll(&mut self, r: u32, f: u32, q: u32, div: u32) {
        // TODO: This should be broken down into a nice state machine like
        // the Kinetis MCG
        assert!(r >= 1 && r <= 4);
        let r = r - 1;
        assert!(f >= 2 && f <= 128 && f % 2 == 0);
        let f = f / 2 - 2;
        let q = match q {
            2 => 0b01,
            4 => 0b10,
            8 => 0b11,
            _ => panic!("Invalid value for Q"),
        };
        assert!(div == 1 || (div % 2) == 0);
        if self.regs.pllcfg.read().get_bit(16) {
            // Make sure the ring oscillator is enabled and switch to it
            self.regs.hfrosccfg.update(|hfrosccfg| {
                hfrosccfg.set_bit(30, true);
            });
            while !self.regs.hfrosccfg.read().get_bit(31) {}
            self.regs.pllcfg.update(|pllcfg| {
                pllcfg.set_bit(16, false);
            });
        }
        self.regs.pllcfg.update(|pll| {
            pll.set_bit(18, true); // bypass PLL
        });

        // Set final PLL dividers
        if div == 1 {
            self.regs.plloutdiv.write(1 << 8);
        } else {
            self.regs.plloutdiv.write(div / 2 - 1);
        }

        // Enable crystal oscillator
        self.regs.hfxosccfg.update(|hfxosccfg| {
            hfxosccfg.set_bit(30, true);
        });
        while !self.regs.hfxosccfg.read().get_bit(31) {}

        // Set PLL dividers and wait for lock
        self.regs.pllcfg.update(|pllcfg| {
            pllcfg.set_bits(0..2, r);
            pllcfg.set_bits(4..10, f);
            pllcfg.set_bits(10..12, q);
            pllcfg.set_bit(17, true);
            pllcfg.set_bit(18, false);
        });
        while !self.regs.pllcfg.read().get_bit(31) {}

        // Switch to PLL as main clock source
        self.regs.pllcfg.update(|pllcfg| {
            pllcfg.set_bit(16, true);
        });
    }
}

impl<M> Drop for Prci<M> {
    fn drop(&mut self) {
        LOCK.store(false, Ordering::Release);
    }
}