teensycore 0.1.0

A kernel for the teensy4.0 microcontroller
Documentation 
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

//! Gpio is reponsible for coordinating input/output
//! settings to various pins on the board.
use crate::phys::addrs;
use crate::phys::*;

pub enum MuxSpeed {
    Slow,
    Fast,
}

pub enum Pin {
    Gpio1 = 1,
    Gpio2 = 2,
    Gpio3 = 3,
    Gpio4 = 4,
    Gpio5 = 5,
    Gpio6 = 6,
    Gpio7 = 7,
    Gpio8 = 8,
    Gpio9 = 9,
}

pub fn gpio_start_clock() {
    assign_bit(addrs::CCM_CCGR0, Bitwise::Or, 0x3 << 30);
    assign_bit(addrs::CCM_CCGR1, Bitwise::Or, (0x3 << 30) | (0x3 << 26));
    assign_bit(addrs::CCM_CCGR2, Bitwise::Or, 0x3 << 26);
    assign_bit(addrs::CCM_CCGR3, Bitwise::Or, 0x3 << 12);
}

fn get_addr(pin: &Pin) -> u32 {
    return match pin {
        Pin::Gpio1 => addrs::GPIO1,
        Pin::Gpio2 => addrs::GPIO2,
        Pin::Gpio3 => addrs::GPIO3,
        Pin::Gpio4 => addrs::GPIO4,
        Pin::Gpio5 => addrs::GPIO5,
        Pin::Gpio6 => addrs::GPIO6,
        Pin::Gpio7 => addrs::GPIO7,
        Pin::Gpio8 => addrs::GPIO8,
        Pin::Gpio9 => addrs::GPIO9,
    }
}

pub fn gpio_speed(pin: &Pin, speed: MuxSpeed) {

    // Gpio5 cannot be muxed.
    if match pin {
        Pin::Gpio5 => true,
        _ => false,
    } {
        return;
    }

    let addr = match pin {
        Pin::Gpio1 => addrs::IOMUXC_GPR_GPR26,
        Pin::Gpio6 => addrs::IOMUXC_GPR_GPR26,
        Pin::Gpio2 => addrs::IOMUXC_GPR_GPR27,
        Pin::Gpio7 => addrs::IOMUXC_GPR_GPR27,
        Pin::Gpio3 => addrs::IOMUXC_GPR_GPR28,
        Pin::Gpio8 => addrs::IOMUXC_GPR_GPR28,
        Pin::Gpio4 => addrs::IOMUXC_GPR_GPR29,
        Pin::Gpio9 => addrs::IOMUXC_GPR_GPR29,

        // This can't ever happen because Gpio5 is escape-hatched already
        _ => addrs::IOMUXC_GPR_GPR26,
    };

    match speed {
        MuxSpeed::Slow => {
            assign(addr, 0x0);
        },
        MuxSpeed::Fast => {
            assign(addr, 0xFFFF_FFFF);
        }
    }
}

pub fn gpio_direction(pin: &Pin, pad: u32, direction: Dir) {
    let addr = get_addr(pin) + 0x4;
    let original_value = read_word(addr);
    
    match direction {
        Dir::Input => {
            assign(addr, original_value & !(0x1 << pad));
        },
        Dir::Output => {
            assign(addr, original_value | (0x1 << pad));
        },
    };
}

pub fn gpio_set(pin: &Pin, mask: u32) {
    let addr = get_addr(pin) + 0x84;
    assign(addr, mask);
}

pub fn gpio_clear(pin: &Pin, mask: u32) {
    let addr = get_addr(pin) + 0x88;
    assign(addr, mask);
}

pub fn gpio_read(pin: &Pin, mask: u32) -> u32 {
    let addr = get_addr(pin) + 0x8;

    // Read from DSR first
    let word = read_word(get_addr(pin));

    return (read_word(addr) | word) & mask;
}