c64 0.1.0-alpha.1

Driver for the Commodore 64 platform
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Commodore 64 peripherals.

use core::marker::PhantomData;
use core::ops;

pub mod asp;
#[cfg(feature = "ultimate")]
pub mod uci;

/// Commodore 64 peripherals.
#[allow(non_snake_case)]
#[non_exhaustive]
pub struct Peripherals {
    /// The address space.
    pub ASP: ASP,

    /// The FAC register.
    pub FAC: FAC,

    /// The ARG register.
    pub ARG: ARG,

    /// The work area for floating point to string conversions.
    pub FPSTR: FPSTR,

    /// The Ultimate Command Interface.
    #[cfg(feature = "ultimate")]
    pub UCI: UCI,
}

// NOTE `no_mangle` is used here to prevent linking different minor versions of this crate
// as that would let you `take` the peripherals more than once (one per minor version).
#[no_mangle]
static PERIPHERALS: () = ();

/// Set to `true` when `take` or `steal` was called to make `Peripherals` a singleton.
static mut TAKEN: bool = false;

impl Peripherals {
    /// Returns all the Commodore 64 peripherals *once*.
    #[inline]
    pub fn take() -> Option<Self> {
        super::interrupt::free(|_| {
            if unsafe { TAKEN } {
                None
            } else {
                Some(unsafe { Peripherals::steal() })
            }
        })
    }

    /// Unchecked version of [`Peripherals::take`].
    #[inline]
    pub unsafe fn steal() -> Self {
        unsafe {
            TAKEN = true;

            Peripherals {
                ASP: ASP {
                    _marker: PhantomData,
                },
                FAC: FAC {
                    _marker: PhantomData,
                },
                ARG: ARG {
                    _marker: PhantomData,
                },
                FPSTR: FPSTR {
                    _marker: PhantomData,
                },
                #[cfg(feature = "ultimate")]
                UCI: UCI {
                    _marker: PhantomData,
                },
            }
        }
    }
}

/// The address space.
pub struct ASP {
    _marker: PhantomData<*const ()>,
}

unsafe impl Send for ASP {}

impl ASP {
    /// Pointer to the register block.
    pub const PTR: *const self::asp::RegisterBlock = 0x0000 as *const _;
}

impl ops::Deref for ASP {
    type Target = self::asp::RegisterBlock;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}

/// The FAC register.
pub struct FAC {
    _marker: PhantomData<*const ()>,
}

unsafe impl Send for FAC {}

/// The ARG register.
pub struct ARG {
    _marker: PhantomData<*const ()>,
}

unsafe impl Send for ARG {}

/// The work area for floating point to string conversions.
pub struct FPSTR {
    _marker: PhantomData<*const ()>,
}

unsafe impl Send for FPSTR {}

/// The Ultimate Command Interface.
#[cfg(feature = "ultimate")]
pub struct UCI {
    _marker: PhantomData<*const ()>,
}

#[cfg(feature = "ultimate")]
unsafe impl Send for UCI {}

#[cfg(feature = "ultimate")]
impl UCI {
    /// Pointer to the register block.
    pub const PTR: *const self::uci::RegisterBlock = 0xdf1b as *const _;
}

#[cfg(feature = "ultimate")]
impl ops::Deref for UCI {
    type Target = self::uci::RegisterBlock;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}