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

use core::{
    marker::PhantomData,
    ops::Deref,
};

use crate::traits::reg_proxy::{
    Reg,
    RegCluster,
};

pub struct RegProxy<T: Reg> {
    _marker: PhantomData<*const T>,
}

impl<T: Reg> RegProxy<T> {
    /// Create a new proxy object
    #[allow(dead_code)]
    pub fn new() -> Self {
        RegProxy {
            _marker: PhantomData,
        }
    }
}

unsafe impl<T> Send for RegProxy<T> where T: Reg {}

impl<T: Reg> Deref for RegProxy<T> {
    type Target = T::Target;

    fn deref(&self) -> &Self::Target {
        // As long as `T` upholds the safety restrictions laid out in the
        // documentation of `Reg`, this should be safe. The pointer is valid for
        // the duration of the program. That means:
        // 1. It can always be dereferenced, so casting to a reference is safe.
        // 2. It is essentially `'static`, so casting to any lifetime is safe.
        unsafe { &*T::get() }
    }
}

// For clusters, e.g. GPIO's set, clr and dirset
pub struct RegClusterProxy<T: RegCluster> {
    _marker: PhantomData<*const [T]>,
}

impl<T: RegCluster> RegClusterProxy<T> {
    pub fn new() -> Self {
        RegClusterProxy {
            _marker: PhantomData,
        }
    }
}

unsafe impl<T> Send for RegClusterProxy<T> where T: RegCluster {}

impl<T: RegCluster> Deref for RegClusterProxy<T> {
    type Target = [T::Target];

    fn deref(&self) -> &Self::Target {
        unsafe { &*T::get() }
    }
}