ioports 1.0.0

A simple library for interacting with IO ports on various platforms (currently, x86, x86_64, and RISCV64).
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! # Safety
//! Given the necessarily arbitrary nature of defining port addresses & their types,
//! the unsafety in this module will be documented here.
//!
//! * Any provided [`crate::PortAddress`] *must* be valid for your current context.
//!
//! For example, on x86-64, the port `0x3F8` typically corresponds to the global serial
//! port used for I/O communication across a motherboard bus. The [`crate::PortAddress`]
//! for such a port is globally valid, but must not be aliased, to avoid putting the port
//! in an undefined state concurrently.
//!
//! * The defined port width (u8/u16/u32/u64/etc) *must* be correct to avoid undefined behaviour.

#![allow(clippy::missing_safety_doc, unsafe_op_in_unsafe_fn)]

pub trait PortRead {
    unsafe fn read(port: PortAddress) -> Self;
}

pub trait PortWrite {
    unsafe fn write(port: PortAddress, value: Self);
}

pub trait PortReadWrite: PortRead + PortWrite {}

/* PORTREAD */
impl PortRead for u8 {
    unsafe fn read(port: PortAddress) -> Self {
        _read8(port)
    }
}

impl PortRead for u16 {
    unsafe fn read(port: PortAddress) -> Self {
        _read16(port)
    }
}

impl PortRead for u32 {
    unsafe fn read(port: PortAddress) -> Self {
        _read32(port)
    }
}

/* PORTWRITE */
impl PortWrite for u8 {
    unsafe fn write(port: PortAddress, value: Self) {
        _write8(port, value)
    }
}

impl PortWrite for u16 {
    unsafe fn write(port: PortAddress, value: Self) {
        _write16(port, value)
    }
}

impl PortWrite for u32 {
    unsafe fn write(port: PortAddress, value: Self) {
        _write32(port, value)
    }
}

pub use portrw_instructions::PortAddress;
use portrw_instructions::*;

#[cfg(target_arch = "x86_64")]
mod portrw_instructions {
    use core::arch::asm;

    pub type PortAddress = u16;

    /* 8 BIT */

    #[doc(hidden)]
    pub unsafe fn _read8(port: PortAddress) -> u8 {
        let result: u8;

        asm!("in al, dx", out("al") result, in("dx") port, options(nostack, nomem, preserves_flags));

        result
    }

    #[doc(hidden)]
    pub unsafe fn _write8(port: PortAddress, value: u8) {
        asm!("out dx, al", in("dx") port, in("al") value, options(nostack, nomem, preserves_flags));
    }

    /* 16 BIT */

    #[doc(hidden)]
    pub unsafe fn _read16(port: PortAddress) -> u16 {
        let result: u16;

        asm!("in ax, dx", out("ax") result, in("dx") port, options(nostack, nomem, preserves_flags));

        result
    }

    #[doc(hidden)]
    pub unsafe fn _write16(port: PortAddress, value: u16) {
        asm!("out dx, ax", in("dx") port, in("ax") value, options(nostack, nomem, preserves_flags));
    }

    /* 32 BIT */

    #[doc(hidden)]
    pub unsafe fn _read32(port: PortAddress) -> u32 {
        let result: u32;

        asm!("in eax, dx", out("eax") result, in("dx") port, options(nostack, nomem, preserves_flags));

        result
    }

    #[doc(hidden)]
    pub unsafe fn _write32(port: PortAddress, value: u32) {
        asm!("out dx, eax", in("dx") port, in("eax") value, options(nostack, nomem, preserves_flags));
    }
}

#[cfg(target_arch = "riscv64")]
mod portrw_instructions {
    pub type PortAddress = usize;

    /* 8 BIT */

    #[doc(hidden)]
    pub unsafe fn _read8(port: PortAddress) -> u8 {
        (port as *const u8).read_volatile()
    }

    #[doc(hidden)]
    pub unsafe fn _write8(port: PortAddress, value: u8) {
        (port as *mut u8).write_volatile(value);
    }

    /* 16 BIT */

    #[doc(hidden)]
    pub unsafe fn _read16(port: PortAddress) -> u16 {
        (port as *const u16).read_volatile()
    }

    #[doc(hidden)]
    pub unsafe fn _write16(port: PortAddress, value: u16) {
        (port as *mut u16).write_volatile(value);
    }

    /* 32 BIT */

    #[doc(hidden)]
    pub unsafe fn _read32(port: PortAddress) -> u32 {
        (port as *const u32).read_volatile()
    }

    #[doc(hidden)]
    pub unsafe fn _write32(port: PortAddress, value: u32) {
        (port as *mut u32).write_volatile(value);
    }
}