Start implementing CRT I/O
[monolithium.git] / kernel / include / common.h
1 /*
2  * common.h
3  *
4  * Copyright (C) 2016 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as
8  * published by the Free Software Foundation, either version 3 of the
9  * License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifndef _COMMON_H_
21 #define _COMMON_H_
22
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sdk/defs.h>
26
27 /* Monolithium-specific Helper Macros */
28 #define SEGMENT_RPL(x) ((x) & 0x03)
29 #define MIN(a, b) ((a) < (b) ? (a) : (b))
30 #define MAX(a, b) ((a) > (b) ? (a) : (b))
31
32 #define VIDEO_MEMORY 0xF0000000
33 #define TEXT_VIDEO_MEMORY 0xB8000
34 #define TEXT_COLOR_BLUE  0x01
35 #define TEXT_COLOR_GREEN 0x02
36 #define TEXT_COLOR_RED   0x04
37 #define TEXT_COLOR_STRONG 0x08
38
39 #define IO_PORT_FUNCTIONS(s, t) \
40     static inline t inport##s(word_t port) \
41     { \
42         t value; \
43         asm volatile ("in" #s " %1, %0\n" : "=a"(value) : "Nd"(port)); \
44         return value; \
45     } \
46     \
47     static inline void outport##s(word_t port, t value) \
48     { \
49         asm volatile ("out" #s " %0, %1\n" :: "a"(value), "Nd"(port)); \
50     } \
51     \
52     static inline void inportbuf##s(word_t port, t *buffer, size_t size) \
53     { \
54         asm volatile("cld\n" \
55                      "rep; ins" #s "\n" \
56                      :"+D"(buffer), "+c"(size) \
57                      : "d"(port) \
58                      : "cc"); \
59     } \
60     \
61     static inline void outportbuf##s(word_t port, const t *buffer, size_t size) \
62     { \
63         asm volatile("cld\n" \
64                      "rep; outs\n" \
65                      : "+S"(buffer), "+c"(size) \
66                      : "d"(port) \
67                      : "cc"); \
68     }
69
70 IO_PORT_FUNCTIONS(b, byte_t)
71 IO_PORT_FUNCTIONS(w, word_t)
72 IO_PORT_FUNCTIONS(l, dword_t)
73
74 static inline bool_t check_ints()
75 {
76     dword_t eflags;
77     asm volatile ("pushfl\n"
78                   "popl %0"
79                   : "=g"(eflags));
80     return (eflags & 0x200) != 0 ? TRUE : FALSE;
81 }
82
83 static inline bool_t enable_ints()
84 {
85     bool_t old = check_ints();
86     asm volatile ("sti");
87     return old;
88 }
89
90 static inline bool_t disable_ints()
91 {
92     bool_t old = check_ints();
93     asm volatile ("cli");
94     return old;
95 }
96
97 static inline void halt()
98 {
99     asm volatile ("hlt");
100 }
101
102 static inline void enable_nmi()
103 {
104     outportb(0x70, inportb(0x70) & 0x7F);
105 }
106
107 static inline void disable_nmi()
108 {
109     outportb(0x70, inportb(0x70) | 0x80);
110 }
111
112 static inline void set_bit(dword_t *bitfield, dword_t bit)
113 {
114     bitfield[bit >> 5] |= 1 << (bit & 0x1F);
115 }
116
117 static inline void clear_bit(dword_t *bitfield, dword_t bit)
118 {
119     bitfield[bit >> 5] &= ~(1 << (bit & 0x1F));
120 }
121
122 static inline bool_t test_bit(dword_t *bitfield, dword_t bit)
123 {
124     return (bitfield[bit >> 5] & (1 << (bit & 0x1F))) ? TRUE : FALSE;
125 }
126
127 static inline void push_to_stack(uintptr_t *stack, uintptr_t value)
128 {
129     *stack -= sizeof(uintptr_t);
130     *((uintptr_t*)(*stack)) = value;
131 }
132
133 static inline uintptr_t pop_from_stack(uintptr_t *stack)
134 {
135     uintptr_t value = *((uintptr_t*)(*stack));
136     *stack += sizeof(uintptr_t);
137     return value;
138 }
139
140 void putchar(char character);
141 void puts(const char *string);
142 void clearscreen();
143 void set_text_color(byte_t color);
144 int vsnprintf(char *output, dword_t count, const char *format, va_list args);
145 int vsprintf(char *output, const char *format, va_list args);
146 int snprintf(char *output, dword_t count, const char *format, ...);
147 int vprintf(const char *format, va_list args);
148 int printf(const char *format, ...);
149 int sprintf(char *output, const char *format, ...);
150 const char *get_error_string(dword_t err_code);
151 int max(int a, int b);
152 int min(int a, int b);
153
154 #endif