orange 0.1.3

Hardware support crate for OrangeSoC.
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
118
119
120
121

use crate::mmio;
use bit_field::BitField;

const BANK_0_MODE: u8 = 0x00;
const BANK_0_DATA: u8 = 0x01;
const BANK_0_INTR_EN: u8 = 0x02;
const BANK_0_INTR_MODE: u8 = 0x03;
const BANK_0_INTR_TRIG: u8 = 0x04;
const BANK_0_INTR_ACK: u8 = 0x05;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum PinMode {
    Input,
    Output,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum IntrMode {
    RisingEdge,
    FallingEdge,
}

#[repr(transparent)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub struct IoPin(pub u32);

impl IoPin {
    pub fn get_mode(&self) -> PinMode {
        assert!(self.0 < 32);
        let is_input = unsafe {
            mmio::read(BANK_0_MODE)
        }.get_bit(self.0 as _);
        if is_input {
            PinMode::Input
        } else {
            PinMode::Output
        }
    }

    pub fn set_mode(&self, mode: PinMode) {
        assert!(self.0 < 32);
        let mut bank = unsafe {
            mmio::read(BANK_0_MODE)
        };
        bank.set_bit(self.0 as _, match mode {
            PinMode::Input => true,
            PinMode::Output => false,
        });
        unsafe {
            mmio::write(BANK_0_MODE, bank);
        }
    }

    pub fn read(&self) -> bool {
        assert!(self.0 < 32);
        unsafe {
            mmio::read(BANK_0_DATA)
        }.get_bit(self.0 as _)
    }

    pub fn write(&self, value: bool) {
        assert!(self.0 < 32);
        let mut bank = unsafe {
            mmio::read(BANK_0_DATA)
        };
        bank.set_bit(self.0 as _, value);
        unsafe {
            mmio::write(BANK_0_DATA, bank);
        }
    }

    pub fn enable_interrupt(&self, mode: IntrMode) {
        let mut bank = unsafe {
            mmio::read(BANK_0_INTR_MODE)
        };
        let mode_bit = match mode {
            IntrMode::RisingEdge => false,
            IntrMode::FallingEdge => true,
        };
        bank.set_bit(self.0 as _, mode_bit);
        unsafe {
            mmio::write(BANK_0_INTR_MODE, bank);
        }

        let mut bank = unsafe {
            mmio::read(BANK_0_INTR_EN)
        };
        bank.set_bit(self.0 as _, true);
        unsafe {
            mmio::write(BANK_0_INTR_EN, bank);
        }
    }

    pub fn disable_interrupt(&self) {
        let mut bank = unsafe {
            mmio::read(BANK_0_INTR_EN)
        };
        bank.set_bit(self.0 as _, false);
        unsafe {
            mmio::write(BANK_0_INTR_EN, bank);
        }
    }

    pub fn ack_interrupt(&self) {
        unsafe {
            mmio::write(BANK_0_INTR_ACK, (1 << self.0));
        }
    }
}

pub fn first_interrupt_pin() -> Option<IoPin> {
    let bank = unsafe {
        mmio::read(BANK_0_INTR_TRIG)
    };
    for i in 0..32u32 {
        if bank.get_bit(i as usize) {
            return Some(IoPin(i));
        }
    }
    None
}