9d261d043312318381e38ffef195c4a65246d773
[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 <limits.h>
24 #include <stdarg.h>
25 #include <stddef.h>
26 #include <stdint.h>
27
28 #define FALSE 0
29 #define TRUE (!FALSE)
30 #define VARIABLE_SIZE 0
31
32 /* Monolithium-specific Type Limits */
33 #define BYTE_MIN  0
34 #define BYTE_MAX  0xFF
35 #define WORD_MIN  0
36 #define WORD_MAX  0xFFFF
37 #define DWORD_MIN 0
38 #define DWORD_MAX 0xFFFFFFFF
39 #define QWORD_MIN 0ULL
40 #define QWORD_MAX 0xFFFFFFFFFFFFFFFFULL
41
42 /* Monolithium Error Codes */
43 #define ERR_SUCCESS   0x00000000
44 #define ERR_NOTFOUND  0xE0000001
45 #define ERR_FORBIDDEN 0xE0000002
46 #define ERR_INVALID   0xE0000003
47 #define ERR_EXISTS    0xE0000004
48 #define ERR_NOMEMORY  0xE0000005
49 #define ERR_HARDWARE  0xE0000006
50 #define ERR_BUSY      0xE0000007
51 #define ERR_NOMEDIA   0xE0000008
52 #define ERR_NOTRESP   0xE0000009
53 #define ERR_WRITEPROT 0xE000000A
54 #define ERR_NOSYSCALL 0xE000000B
55 #define ERR_TIMEOUT   0xE000000C
56 #define ERR_BADPTR    0xE000000D
57 #define ERR_CANCELED  0xE000000E
58 #define ERR_ISDIR     0xE000000F
59 #define ERR_ISNOTDIR  0xE0000010
60 #define ERR_DISKFULL  0xE0000011
61 #define ERR_MEDIACHG  0xE0000012
62 #define ERR_BEYOND    0xE0000013
63 #define ERR_SMALLBUF  0xE0000014
64 #define ERR_NOMORE    0xE0000015
65 #define MAX_ERR       0xE0000016
66
67 /* Monolithium-specific Helper Macros */
68 #define UNUSED_PARAMETER(x) (x)=(x)
69 #define SEGMENT_RPL(x) ((x) & 0x03)
70 #define OFFSET_OF(type, field) ((uintptr_t)(&((type*)NULL)->field))
71 #define CONTAINER_OF(ptr, type, field) ((type*)((uintptr_t)(ptr) - OFFSET_OF(type, field)))
72 #define MIN(a, b) ((a) < (b) ? (a) : (b))
73 #define MAX(a, b) ((a) > (b) ? (a) : (b))
74
75 #define MAX_PATH 16384
76
77 #define VIDEO_MEMORY 0xF0000000
78 #define TEXT_VIDEO_MEMORY 0xB8000
79 #define TEXT_COLOR_BLUE  0x01
80 #define TEXT_COLOR_GREEN 0x02
81 #define TEXT_COLOR_RED   0x04
82 #define TEXT_COLOR_STRONG 0x08
83
84 /* Monolithium-specific Types */
85 typedef uint8_t bool_t;
86 typedef uint8_t byte_t;
87 typedef uint16_t word_t;
88 typedef uint32_t dword_t;
89 typedef uint64_t qword_t;
90 typedef bool_t critical_t;
91
92 static inline byte_t inportb(word_t port)
93 {
94     byte_t byte;
95     asm volatile ("inb %1, %0" : "=a"(byte) : "Nd"(port));
96     return byte;
97 }
98
99 static inline void outportb(word_t port, byte_t byte)
100 {
101     asm volatile ("outb %0, %1" :: "a"(byte), "Nd"(port));
102 }
103
104 static inline word_t inportw(unsigned short port)
105 {
106     word_t word;
107     asm volatile ("inw %1, %0" : "=a"(word) : "Nd"(port));
108     return word;
109 }
110
111 static inline void outportw(word_t port, unsigned short word)
112 {
113     asm volatile ("outw %0, %1" :: "a"(word), "Nd"(port));
114 }
115
116 static inline dword_t inportl(word_t port)
117 {
118     dword_t dword;
119     asm volatile ("inl %1, %0" : "=a"(dword) : "Nd"(port));
120     return dword;
121 }
122
123 static inline void outportl(word_t port, dword_t dword)
124 {
125     asm volatile ("outl %0, %1" :: "a"(dword), "Nd"(port));
126 }
127
128 static inline void enable_ints()
129 {
130     asm volatile ("sti");
131 }
132
133 static inline void disable_ints()
134 {
135     asm volatile ("cli");
136 }
137
138 static inline bool_t check_ints()
139 {
140     dword_t eflags;
141     asm volatile ("pushfl\npopl %0" : "=g"(eflags));
142     return (eflags & 0x200) != 0 ? TRUE : FALSE;
143 }
144
145 static inline void halt()
146 {
147     asm volatile ("hlt");
148 }
149
150 static inline void enable_nmi()
151 {
152     outportb(0x70, inportb(0x70) & 0x7F);
153 }
154
155 static inline void disable_nmi()
156 {
157     outportb(0x70, inportb(0x70) | 0x80);
158 }
159
160 static inline void set_bit(dword_t *bitfield, dword_t bit)
161 {
162     bitfield[bit >> 5] |= 1 << (bit & 0x1F);
163 }
164
165 static inline void clear_bit(dword_t *bitfield, dword_t bit)
166 {
167     bitfield[bit >> 5] &= ~(1 << (bit & 0x1F));
168 }
169
170 static inline bool_t test_bit(dword_t *bitfield, dword_t bit)
171 {
172     return (bitfield[bit >> 5] & (1 << (bit & 0x1F))) ? TRUE : FALSE;
173 }
174
175 static inline void push_to_stack(uintptr_t *stack, uintptr_t value)
176 {
177     *stack -= sizeof(uintptr_t);
178     *((uintptr_t*)(*stack)) = value;
179 }
180
181 static inline uintptr_t pop_from_stack(uintptr_t *stack)
182 {
183     uintptr_t value = *((uintptr_t*)(*stack));
184     *stack += sizeof(uintptr_t);
185     return value;
186 }
187
188 void enter_critical(critical_t *critical);
189 void leave_critical(critical_t *critical);
190 int strlen(const char *str);
191 void strrev(char *str);
192 char *strcpy(char *destination, const char *source);
193 char *strcat(char *destination, const char *source);
194 char *strncpy(char *destination, const char *source, dword_t num);
195 int strcmp(const char *str1, const char *str2);
196 char *strchr(const char *str, char c);
197 char *strrchr(const char *str, char c);
198 int strncmp(const char *str1, const char *str2, int length);
199 char *strstr(const char *haystack, const char *needle);
200 char *strtok(char *str, const char *delimiters, char **endptr);
201 dword_t strtoul(const char *str, char **endptr, int base);
202 qword_t strtoull(const char *str, char **endptr, int base);
203 char *strdup(const char *source);
204 int isprint(int c);
205 int isdigit(int c);
206 int isxdigit(int c);
207 int isspace(int c);
208 char tolower(char c);
209 char toupper(char c);
210 void memset(void *ptr, byte_t value, dword_t size);
211 int memcmp(const void *mem1, const void *mem2, dword_t size);
212 void memcpy(void *destination, const void *source, dword_t size);
213 void memmove(void *destination, const void *source, dword_t size);
214 char *itoa(int value, char *str, int base);
215 void putchar(char character);
216 void puts(const char *string);
217 void clearscreen();
218 void set_text_color(byte_t color);
219 int vsnprintf(char *output, dword_t count, const char *format, va_list args);
220 int vsprintf(char *output, const char *format, va_list args);
221 int snprintf(char *output, dword_t count, const char *format, ...);
222 int vprintf(const char *format, va_list args);
223 int printf(const char *format, ...);
224 int sprintf(char *output, const char *format, ...);
225 const char *get_error_string(dword_t err_code);
226 int max(int a, int b);
227 int min(int a, int b);
228 void qsort(void *base, dword_t nmemb, dword_t size, int (*compare)(const void*, const void*));
229 void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*));
230
231 #endif