CeDOS - include/assembly.h

include/assembly.h (view raw)

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
/*! \file
 * Wrapper for low-level assembler instructions.
 */
#ifndef ASSEMBLY_H
#define ASSEMBLY_H

#include <stdint.h>

/*!
 * Sends a single byte to the specified port.
 * \param msg The byte to be sent.
 * \param port The destination port.
 */
__attribute((always_inline)) inline void outb(uint8_t msg, uint16_t port) {
    __asm__ volatile ("outb %0, %1" : : "a" (msg), "Nd" (port));
}

/*!
 * Retrieves a single byte from the specified port.
 * \param port The source port.
 * \return The recieved byte.
 */
__attribute((always_inline)) inline uint8_t inb(uint16_t port) {
    uint8_t msg;
    __asm__ volatile ("inb %1, %0" : "=a" (msg) : "Nd" (port));
    return msg;
}

/*!
 * nop
 */
__attribute__((always_inline)) inline void nop(void) {
    __asm__ volatile ("nop");
}

/*!
 * Deactivates all interrupts.
 */
__attribute__((always_inline)) inline void cli(void) {
    __asm__ volatile ("cli");
}

/*!
 * Reactivates all interrupts.
 */
__attribute__((always_inline)) inline void sti(void) {
    __asm__ volatile ("sti");
}

/*!
 * Pushes the contents of the EFLAGS register onto the stack.
 */
__attribute__((always_inline)) inline void pushf(void) {
    __asm__ volatile ("pushf");
}

/*!
 * Pops the contents of the EFLAGS register from the top of the stack.
 */
__attribute__((always_inline)) inline void popf(void) {
    __asm__ volatile ("popf");
}

/*!
 * Pushes the contents of the general purpose registers onto the stack.
 */
__attribute__((always_inline)) inline void pusha(void) {
    __asm__ volatile ("pusha" : : : "eax", "ebx", "ecx", "edx", "esi", "edi");
}

/*!
 * Pops the contents of the general purpose registers off the top of the stack.
 */
__attribute__((always_inline)) inline void popa(void) {
    __asm__ volatile ("popa" : : : "eax", "ebx", "ecx", "edx", "esi", "edi");
}

/*!
 * CPUID
 */
__attribute__((always_inline)) inline void cpuid(uint32_t eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) {
    __asm__ volatile (  "mov %3, %%eax;"
                        "cpuid;"
                        "mov %%ebx, %0;"
                        "mov %%ecx, %1;"
                        "mov %%edx, %2"
                        : "=m" (*ebx), "=m" (*ecx), "=m" (*edx)
                        : "Nd" (eax));
}

/*!
 * Used to find out the current value of the flags register.
 * \return Value of the EFLAGS-register.
 */
__attribute((always_inline)) inline uint32_t get_eflags() {
    uint32_t eflags;
    __asm__ volatile ("pushf; pop %%eax; mov %%eax, %0" : "=m" (eflags) : : "eax");
    return eflags;
}

/*!
 * Sets the value of the EFLAGS-register.
 * \param eflags New value of the EFLAGS-register.
 */
__attribute__((always_inline)) inline void set_eflags(uint32_t eflags) {
    __asm__ volatile ("mov %0, %%eax; push %%eax; popf" : : "m" (eflags) : "eax");
}

/*!
 * Waits for the next interrupt.
 */
__attribute__((always_inline)) inline void hlt(void) {
    __asm__ volatile ("hlt");
}

/*!
 * Causes an interrupt
 */
#define INT(n) __asm__ volatile ("int $"  #n)

#endif