1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* -*- linux-c -*- ------------------------------------------------------- * 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright 2007 rPath, Inc. - All Rights Reserved 6 * Copyright 2009 Intel Corporation; author H. Peter Anvin 7 * 8 * ----------------------------------------------------------------------- */ 9 10 /* 11 * Header file for the real-mode kernel code 12 */ 13 14 #ifndef BOOT_BOOT_H 15 #define BOOT_BOOT_H 16 17 #define STACK_SIZE 1024 /* Minimum number of bytes for stack */ 18 19 #ifndef __ASSEMBLY__ 20 21 #include <linux/stdarg.h> 22 #include <linux/types.h> 23 #include <linux/edd.h> 24 #include <asm/setup.h> 25 #include <asm/asm.h> 26 #include "bitops.h" 27 #include "ctype.h" 28 #include "cpuflags.h" 29 30 /* Useful macros */ 31 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) 32 33 extern struct setup_header hdr; 34 extern struct boot_params boot_params; 35 36 #define cpu_relax() asm volatile("rep; nop") 37 38 /* Basic port I/O */ 39 static inline void outb(u8 v, u16 port) 40 { 41 asm volatile("outb %0,%1" : : "a" (v), "dN" (port)); 42 } 43 static inline u8 inb(u16 port) 44 { 45 u8 v; 46 asm volatile("inb %1,%0" : "=a" (v) : "dN" (port)); 47 return v; 48 } 49 50 static inline void outw(u16 v, u16 port) 51 { 52 asm volatile("outw %0,%1" : : "a" (v), "dN" (port)); 53 } 54 static inline u16 inw(u16 port) 55 { 56 u16 v; 57 asm volatile("inw %1,%0" : "=a" (v) : "dN" (port)); 58 return v; 59 } 60 61 static inline void outl(u32 v, u16 port) 62 { 63 asm volatile("outl %0,%1" : : "a" (v), "dN" (port)); 64 } 65 static inline u32 inl(u16 port) 66 { 67 u32 v; 68 asm volatile("inl %1,%0" : "=a" (v) : "dN" (port)); 69 return v; 70 } 71 72 static inline void io_delay(void) 73 { 74 const u16 DELAY_PORT = 0x80; 75 asm volatile("outb %%al,%0" : : "dN" (DELAY_PORT)); 76 } 77 78 /* These functions are used to reference data in other segments. */ 79 80 static inline u16 ds(void) 81 { 82 u16 seg; 83 asm("movw %%ds,%0" : "=rm" (seg)); 84 return seg; 85 } 86 87 static inline void set_fs(u16 seg) 88 { 89 asm volatile("movw %0,%%fs" : : "rm" (seg)); 90 } 91 static inline u16 fs(void) 92 { 93 u16 seg; 94 asm volatile("movw %%fs,%0" : "=rm" (seg)); 95 return seg; 96 } 97 98 static inline void set_gs(u16 seg) 99 { 100 asm volatile("movw %0,%%gs" : : "rm" (seg)); 101 } 102 static inline u16 gs(void) 103 { 104 u16 seg; 105 asm volatile("movw %%gs,%0" : "=rm" (seg)); 106 return seg; 107 } 108 109 typedef unsigned int addr_t; 110 111 static inline u8 rdfs8(addr_t addr) 112 { 113 u8 *ptr = (u8 *)absolute_pointer(addr); 114 u8 v; 115 asm volatile("movb %%fs:%1,%0" : "=q" (v) : "m" (*ptr)); 116 return v; 117 } 118 static inline u16 rdfs16(addr_t addr) 119 { 120 u16 *ptr = (u16 *)absolute_pointer(addr); 121 u16 v; 122 asm volatile("movw %%fs:%1,%0" : "=r" (v) : "m" (*ptr)); 123 return v; 124 } 125 static inline u32 rdfs32(addr_t addr) 126 { 127 u32 *ptr = (u32 *)absolute_pointer(addr); 128 u32 v; 129 asm volatile("movl %%fs:%1,%0" : "=r" (v) : "m" (*ptr)); 130 return v; 131 } 132 133 static inline void wrfs8(u8 v, addr_t addr) 134 { 135 u8 *ptr = (u8 *)absolute_pointer(addr); 136 asm volatile("movb %1,%%fs:%0" : "+m" (*ptr) : "qi" (v)); 137 } 138 static inline void wrfs16(u16 v, addr_t addr) 139 { 140 u16 *ptr = (u16 *)absolute_pointer(addr); 141 asm volatile("movw %1,%%fs:%0" : "+m" (*ptr) : "ri" (v)); 142 } 143 static inline void wrfs32(u32 v, addr_t addr) 144 { 145 u32 *ptr = (u32 *)absolute_pointer(addr); 146 asm volatile("movl %1,%%fs:%0" : "+m" (*ptr) : "ri" (v)); 147 } 148 149 static inline u8 rdgs8(addr_t addr) 150 { 151 u8 *ptr = (u8 *)absolute_pointer(addr); 152 u8 v; 153 asm volatile("movb %%gs:%1,%0" : "=q" (v) : "m" (*ptr)); 154 return v; 155 } 156 static inline u16 rdgs16(addr_t addr) 157 { 158 u16 *ptr = (u16 *)absolute_pointer(addr); 159 u16 v; 160 asm volatile("movw %%gs:%1,%0" : "=r" (v) : "m" (*ptr)); 161 return v; 162 } 163 static inline u32 rdgs32(addr_t addr) 164 { 165 u32 *ptr = (u32 *)absolute_pointer(addr); 166 u32 v; 167 asm volatile("movl %%gs:%1,%0" : "=r" (v) : "m" (*ptr)); 168 return v; 169 } 170 171 static inline void wrgs8(u8 v, addr_t addr) 172 { 173 u8 *ptr = (u8 *)absolute_pointer(addr); 174 asm volatile("movb %1,%%gs:%0" : "+m" (*ptr) : "qi" (v)); 175 } 176 static inline void wrgs16(u16 v, addr_t addr) 177 { 178 u16 *ptr = (u16 *)absolute_pointer(addr); 179 asm volatile("movw %1,%%gs:%0" : "+m" (*ptr) : "ri" (v)); 180 } 181 static inline void wrgs32(u32 v, addr_t addr) 182 { 183 u32 *ptr = (u32 *)absolute_pointer(addr); 184 asm volatile("movl %1,%%gs:%0" : "+m" (*ptr) : "ri" (v)); 185 } 186 187 /* Note: these only return true/false, not a signed return value! */ 188 static inline bool memcmp_fs(const void *s1, addr_t s2, size_t len) 189 { 190 bool diff; 191 asm volatile("fs; repe; cmpsb" CC_SET(nz) 192 : CC_OUT(nz) (diff), "+D" (s1), "+S" (s2), "+c" (len)); 193 return diff; 194 } 195 static inline bool memcmp_gs(const void *s1, addr_t s2, size_t len) 196 { 197 bool diff; 198 asm volatile("gs; repe; cmpsb" CC_SET(nz) 199 : CC_OUT(nz) (diff), "+D" (s1), "+S" (s2), "+c" (len)); 200 return diff; 201 } 202 203 /* Heap -- available for dynamic lists. */ 204 extern char _end[]; 205 extern char *HEAP; 206 extern char *heap_end; 207 #define RESET_HEAP() ((void *)( HEAP = _end )) 208 static inline char *__get_heap(size_t s, size_t a, size_t n) 209 { 210 char *tmp; 211 212 HEAP = (char *)(((size_t)HEAP+(a-1)) & ~(a-1)); 213 tmp = HEAP; 214 HEAP += s*n; 215 return tmp; 216 } 217 #define GET_HEAP(type, n) \ 218 ((type *)__get_heap(sizeof(type),__alignof__(type),(n))) 219 220 static inline bool heap_free(size_t n) 221 { 222 return (int)(heap_end-HEAP) >= (int)n; 223 } 224 225 /* copy.S */ 226 227 void copy_to_fs(addr_t dst, void *src, size_t len); 228 void *copy_from_fs(void *dst, addr_t src, size_t len); 229 void copy_to_gs(addr_t dst, void *src, size_t len); 230 void *copy_from_gs(void *dst, addr_t src, size_t len); 231 232 /* a20.c */ 233 int enable_a20(void); 234 235 /* apm.c */ 236 int query_apm_bios(void); 237 238 /* bioscall.c */ 239 struct biosregs { 240 union { 241 struct { 242 u32 edi; 243 u32 esi; 244 u32 ebp; 245 u32 _esp; 246 u32 ebx; 247 u32 edx; 248 u32 ecx; 249 u32 eax; 250 u32 _fsgs; 251 u32 _dses; 252 u32 eflags; 253 }; 254 struct { 255 u16 di, hdi; 256 u16 si, hsi; 257 u16 bp, hbp; 258 u16 _sp, _hsp; 259 u16 bx, hbx; 260 u16 dx, hdx; 261 u16 cx, hcx; 262 u16 ax, hax; 263 u16 gs, fs; 264 u16 es, ds; 265 u16 flags, hflags; 266 }; 267 struct { 268 u8 dil, dih, edi2, edi3; 269 u8 sil, sih, esi2, esi3; 270 u8 bpl, bph, ebp2, ebp3; 271 u8 _spl, _sph, _esp2, _esp3; 272 u8 bl, bh, ebx2, ebx3; 273 u8 dl, dh, edx2, edx3; 274 u8 cl, ch, ecx2, ecx3; 275 u8 al, ah, eax2, eax3; 276 }; 277 }; 278 }; 279 void intcall(u8 int_no, const struct biosregs *ireg, struct biosregs *oreg); 280 281 /* cmdline.c */ 282 int __cmdline_find_option(unsigned long cmdline_ptr, const char *option, char *buffer, int bufsize); 283 int __cmdline_find_option_bool(unsigned long cmdline_ptr, const char *option); 284 static inline int cmdline_find_option(const char *option, char *buffer, int bufsize) 285 { 286 unsigned long cmd_line_ptr = boot_params.hdr.cmd_line_ptr; 287 288 if (cmd_line_ptr >= 0x100000) 289 return -1; /* inaccessible */ 290 291 return __cmdline_find_option(cmd_line_ptr, option, buffer, bufsize); 292 } 293 294 static inline int cmdline_find_option_bool(const char *option) 295 { 296 unsigned long cmd_line_ptr = boot_params.hdr.cmd_line_ptr; 297 298 if (cmd_line_ptr >= 0x100000) 299 return -1; /* inaccessible */ 300 301 return __cmdline_find_option_bool(cmd_line_ptr, option); 302 } 303 304 /* cpu.c, cpucheck.c */ 305 int check_cpu(int *cpu_level_ptr, int *req_level_ptr, u32 **err_flags_ptr); 306 int check_knl_erratum(void); 307 int validate_cpu(void); 308 309 /* early_serial_console.c */ 310 extern int early_serial_base; 311 void console_init(void); 312 313 /* edd.c */ 314 void query_edd(void); 315 316 /* header.S */ 317 void __attribute__((noreturn)) die(void); 318 319 /* memory.c */ 320 void detect_memory(void); 321 322 /* pm.c */ 323 void __attribute__((noreturn)) go_to_protected_mode(void); 324 325 /* pmjump.S */ 326 void __attribute__((noreturn)) 327 protected_mode_jump(u32 entrypoint, u32 bootparams); 328 329 /* printf.c */ 330 int sprintf(char *buf, const char *fmt, ...); 331 int vsprintf(char *buf, const char *fmt, va_list args); 332 int printf(const char *fmt, ...); 333 334 /* regs.c */ 335 void initregs(struct biosregs *regs); 336 337 /* string.c */ 338 int strcmp(const char *str1, const char *str2); 339 int strncmp(const char *cs, const char *ct, size_t count); 340 size_t strnlen(const char *s, size_t maxlen); 341 unsigned int atou(const char *s); 342 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base); 343 size_t strlen(const char *s); 344 char *strchr(const char *s, int c); 345 346 /* tty.c */ 347 void puts(const char *); 348 void putchar(int); 349 int getchar(void); 350 void kbd_flush(void); 351 int getchar_timeout(void); 352 353 /* video.c */ 354 void set_video(void); 355 356 /* video-mode.c */ 357 int set_mode(u16 mode); 358 int mode_defined(u16 mode); 359 void probe_cards(int unsafe); 360 361 /* video-vesa.c */ 362 void vesa_store_edid(void); 363 364 #endif /* __ASSEMBLY__ */ 365 366 #endif /* BOOT_BOOT_H */ 367