Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 1 | // Basic x86 asm functions. |
| 2 | #ifndef __X86_H |
| 3 | #define __X86_H |
| 4 | |
| 5 | // CPU flag bitdefs |
| 6 | #define F_CF (1<<0) |
| 7 | #define F_ZF (1<<6) |
| 8 | #define F_IF (1<<9) |
| 9 | #define F_ID (1<<21) |
| 10 | |
| 11 | // CR0 flags |
| 12 | #define CR0_PG (1<<31) // Paging |
| 13 | #define CR0_CD (1<<30) // Cache disable |
| 14 | #define CR0_NW (1<<29) // Not Write-through |
| 15 | #define CR0_PE (1<<0) // Protection enable |
| 16 | |
Kevin O'Connor | 341f8d9 | 2014-10-11 13:16:12 -0400 | [diff] [blame] | 17 | // PORT_A20 bitdefs |
| 18 | #define PORT_A20 0x0092 |
| 19 | #define A20_ENABLE_BIT 0x02 |
| 20 | |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 21 | #ifndef __ASSEMBLY__ |
| 22 | |
| 23 | #include "types.h" // u32 |
| 24 | |
| 25 | static inline void irq_disable(void) |
| 26 | { |
| 27 | asm volatile("cli": : :"memory"); |
| 28 | } |
| 29 | |
| 30 | static inline void irq_enable(void) |
| 31 | { |
| 32 | asm volatile("sti": : :"memory"); |
| 33 | } |
| 34 | |
| 35 | static inline u32 save_flags(void) |
| 36 | { |
| 37 | u32 flags; |
| 38 | asm volatile("pushfl ; popl %0" : "=rm" (flags)); |
| 39 | return flags; |
| 40 | } |
| 41 | |
| 42 | static inline void restore_flags(u32 flags) |
| 43 | { |
| 44 | asm volatile("pushl %0 ; popfl" : : "g" (flags) : "memory", "cc"); |
| 45 | } |
| 46 | |
| 47 | static inline void cpu_relax(void) |
| 48 | { |
| 49 | asm volatile("rep ; nop": : :"memory"); |
| 50 | } |
| 51 | |
| 52 | static inline void nop(void) |
| 53 | { |
| 54 | asm volatile("nop"); |
| 55 | } |
| 56 | |
| 57 | static inline void hlt(void) |
| 58 | { |
| 59 | asm volatile("hlt": : :"memory"); |
| 60 | } |
| 61 | |
| 62 | static inline void wbinvd(void) |
| 63 | { |
| 64 | asm volatile("wbinvd": : :"memory"); |
| 65 | } |
| 66 | |
| 67 | #define CPUID_TSC (1 << 4) |
| 68 | #define CPUID_MSR (1 << 5) |
| 69 | #define CPUID_APIC (1 << 9) |
| 70 | #define CPUID_MTRR (1 << 12) |
Igor Mammedov | cb75c91 | 2016-10-13 14:38:28 +0200 | [diff] [blame] | 71 | #define CPUID_X2APIC (1 << 21) |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 72 | static inline void __cpuid(u32 index, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx) |
| 73 | { |
| 74 | asm("cpuid" |
| 75 | : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx) |
| 76 | : "0" (index)); |
| 77 | } |
| 78 | |
Kevin O'Connor | 62de31b | 2015-09-22 12:35:00 -0400 | [diff] [blame] | 79 | static inline u32 cr0_read(void) { |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 80 | u32 cr0; |
| 81 | asm("movl %%cr0, %0" : "=r"(cr0)); |
| 82 | return cr0; |
| 83 | } |
Kevin O'Connor | 62de31b | 2015-09-22 12:35:00 -0400 | [diff] [blame] | 84 | static inline void cr0_write(u32 cr0) { |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 85 | asm("movl %0, %%cr0" : : "r"(cr0)); |
| 86 | } |
Kevin O'Connor | 62de31b | 2015-09-22 12:35:00 -0400 | [diff] [blame] | 87 | static inline void cr0_mask(u32 off, u32 on) { |
| 88 | cr0_write((cr0_read() & ~off) | on); |
| 89 | } |
| 90 | static inline u16 cr0_vm86_read(void) { |
Kevin O'Connor | 251e263 | 2015-03-17 11:37:25 -0400 | [diff] [blame] | 91 | u16 cr0; |
| 92 | asm("smsww %0" : "=r"(cr0)); |
| 93 | return cr0; |
| 94 | } |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 95 | |
| 96 | static inline u64 rdmsr(u32 index) |
| 97 | { |
| 98 | u64 ret; |
| 99 | asm ("rdmsr" : "=A"(ret) : "c"(index)); |
| 100 | return ret; |
| 101 | } |
| 102 | |
| 103 | static inline void wrmsr(u32 index, u64 val) |
| 104 | { |
| 105 | asm volatile ("wrmsr" : : "c"(index), "A"(val)); |
| 106 | } |
| 107 | |
| 108 | static inline u64 rdtscll(void) |
| 109 | { |
| 110 | u64 val; |
| 111 | asm volatile("rdtsc" : "=A" (val)); |
| 112 | return val; |
| 113 | } |
| 114 | |
| 115 | static inline u32 __ffs(u32 word) |
| 116 | { |
| 117 | asm("bsf %1,%0" |
| 118 | : "=r" (word) |
| 119 | : "rm" (word)); |
| 120 | return word; |
| 121 | } |
| 122 | static inline u32 __fls(u32 word) |
| 123 | { |
| 124 | asm("bsr %1,%0" |
| 125 | : "=r" (word) |
| 126 | : "rm" (word)); |
| 127 | return word; |
| 128 | } |
| 129 | |
| 130 | static inline u32 getesp(void) { |
| 131 | u32 esp; |
| 132 | asm("movl %%esp, %0" : "=rm"(esp)); |
| 133 | return esp; |
| 134 | } |
| 135 | |
Stefan Berger | 5aa2a75 | 2015-03-23 14:22:17 -0400 | [diff] [blame] | 136 | static inline u32 rol(u32 val, u16 rol) { |
| 137 | u32 res; |
| 138 | asm volatile("roll %%cl, %%eax" |
| 139 | : "=a" (res) : "a" (val), "c" (rol)); |
| 140 | return res; |
| 141 | } |
| 142 | |
Stefan Berger | 4e57a54 | 2021-06-14 13:35:48 -0400 | [diff] [blame] | 143 | static inline u32 ror(u32 val, u16 ror) { |
| 144 | u32 res; |
| 145 | asm volatile("rorl %%cl, %%eax" |
| 146 | : "=a" (res) : "a" (val), "c" (ror)); |
| 147 | return res; |
| 148 | } |
| 149 | |
Kevin O'Connor | 4ade523 | 2013-09-18 21:41:48 -0400 | [diff] [blame] | 150 | static inline void outb(u8 value, u16 port) { |
| 151 | __asm__ __volatile__("outb %b0, %w1" : : "a"(value), "Nd"(port)); |
| 152 | } |
| 153 | static inline void outw(u16 value, u16 port) { |
| 154 | __asm__ __volatile__("outw %w0, %w1" : : "a"(value), "Nd"(port)); |
| 155 | } |
| 156 | static inline void outl(u32 value, u16 port) { |
| 157 | __asm__ __volatile__("outl %0, %w1" : : "a"(value), "Nd"(port)); |
| 158 | } |
| 159 | static inline u8 inb(u16 port) { |
| 160 | u8 value; |
| 161 | __asm__ __volatile__("inb %w1, %b0" : "=a"(value) : "Nd"(port)); |
| 162 | return value; |
| 163 | } |
| 164 | static inline u16 inw(u16 port) { |
| 165 | u16 value; |
| 166 | __asm__ __volatile__("inw %w1, %w0" : "=a"(value) : "Nd"(port)); |
| 167 | return value; |
| 168 | } |
| 169 | static inline u32 inl(u16 port) { |
| 170 | u32 value; |
| 171 | __asm__ __volatile__("inl %w1, %0" : "=a"(value) : "Nd"(port)); |
| 172 | return value; |
| 173 | } |
| 174 | |
| 175 | static inline void insb(u16 port, u8 *data, u32 count) { |
| 176 | asm volatile("rep insb (%%dx), %%es:(%%edi)" |
| 177 | : "+c"(count), "+D"(data) : "d"(port) : "memory"); |
| 178 | } |
| 179 | static inline void insw(u16 port, u16 *data, u32 count) { |
| 180 | asm volatile("rep insw (%%dx), %%es:(%%edi)" |
| 181 | : "+c"(count), "+D"(data) : "d"(port) : "memory"); |
| 182 | } |
| 183 | static inline void insl(u16 port, u32 *data, u32 count) { |
| 184 | asm volatile("rep insl (%%dx), %%es:(%%edi)" |
| 185 | : "+c"(count), "+D"(data) : "d"(port) : "memory"); |
| 186 | } |
| 187 | // XXX - outs not limited to es segment |
| 188 | static inline void outsb(u16 port, u8 *data, u32 count) { |
| 189 | asm volatile("rep outsb %%es:(%%esi), (%%dx)" |
| 190 | : "+c"(count), "+S"(data) : "d"(port) : "memory"); |
| 191 | } |
| 192 | static inline void outsw(u16 port, u16 *data, u32 count) { |
| 193 | asm volatile("rep outsw %%es:(%%esi), (%%dx)" |
| 194 | : "+c"(count), "+S"(data) : "d"(port) : "memory"); |
| 195 | } |
| 196 | static inline void outsl(u16 port, u32 *data, u32 count) { |
| 197 | asm volatile("rep outsl %%es:(%%esi), (%%dx)" |
| 198 | : "+c"(count), "+S"(data) : "d"(port) : "memory"); |
| 199 | } |
| 200 | |
Kevin O'Connor | eee06e0 | 2015-09-29 10:14:58 -0400 | [diff] [blame] | 201 | /* Compiler barrier is enough as an x86 CPU does not reorder reads or writes */ |
| 202 | static inline void smp_rmb(void) { |
| 203 | barrier(); |
| 204 | } |
| 205 | static inline void smp_wmb(void) { |
| 206 | barrier(); |
| 207 | } |
| 208 | |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 209 | static inline void writel(void *addr, u32 val) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 210 | barrier(); |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 211 | *(volatile u32 *)addr = val; |
| 212 | } |
| 213 | static inline void writew(void *addr, u16 val) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 214 | barrier(); |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 215 | *(volatile u16 *)addr = val; |
| 216 | } |
| 217 | static inline void writeb(void *addr, u8 val) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 218 | barrier(); |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 219 | *(volatile u8 *)addr = val; |
| 220 | } |
Marc-André Lureau | 8694c3b | 2018-02-26 09:12:11 -0500 | [diff] [blame] | 221 | static inline u64 readq(const void *addr) { |
| 222 | u64 val = *(volatile const u64 *)addr; |
| 223 | barrier(); |
| 224 | return val; |
| 225 | } |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 226 | static inline u32 readl(const void *addr) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 227 | u32 val = *(volatile const u32 *)addr; |
| 228 | barrier(); |
| 229 | return val; |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 230 | } |
| 231 | static inline u16 readw(const void *addr) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 232 | u16 val = *(volatile const u16 *)addr; |
| 233 | barrier(); |
| 234 | return val; |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 235 | } |
| 236 | static inline u8 readb(const void *addr) { |
Ameya Palande | bc82fa4 | 2015-02-17 14:00:49 -0800 | [diff] [blame] | 237 | u8 val = *(volatile const u8 *)addr; |
| 238 | barrier(); |
| 239 | return val; |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 240 | } |
| 241 | |
| 242 | // GDT bits |
| 243 | #define GDT_CODE (0x9bULL << 40) // Code segment - P,R,A bits also set |
| 244 | #define GDT_DATA (0x93ULL << 40) // Data segment - W,A bits also set |
| 245 | #define GDT_B (0x1ULL << 54) // Big flag |
| 246 | #define GDT_G (0x1ULL << 55) // Granularity flag |
| 247 | // GDT bits for segment base |
| 248 | #define GDT_BASE(v) ((((u64)(v) & 0xff000000) << 32) \ |
| 249 | | (((u64)(v) & 0x00ffffff) << 16)) |
| 250 | // GDT bits for segment limit (0-1Meg) |
| 251 | #define GDT_LIMIT(v) ((((u64)(v) & 0x000f0000) << 32) \ |
| 252 | | (((u64)(v) & 0x0000ffff) << 0)) |
| 253 | // GDT bits for segment limit (0-4Gig in 4K chunks) |
| 254 | #define GDT_GRANLIMIT(v) (GDT_G | GDT_LIMIT((v) >> 12)) |
| 255 | |
| 256 | struct descloc_s { |
| 257 | u16 length; |
| 258 | u32 addr; |
| 259 | } PACKED; |
| 260 | |
Kevin O'Connor | 0f0612e | 2013-12-04 11:48:05 -0500 | [diff] [blame] | 261 | static inline void sgdt(struct descloc_s *desc) { |
| 262 | asm("sgdtl %0" : "=m"(*desc)); |
| 263 | } |
| 264 | static inline void lgdt(struct descloc_s *desc) { |
| 265 | asm("lgdtl %0" : : "m"(*desc) : "memory"); |
| 266 | } |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 267 | |
Kevin O'Connor | 341f8d9 | 2014-10-11 13:16:12 -0400 | [diff] [blame] | 268 | static inline u8 get_a20(void) { |
| 269 | return (inb(PORT_A20) & A20_ENABLE_BIT) != 0; |
| 270 | } |
| 271 | |
| 272 | static inline u8 set_a20(u8 cond) { |
Kevin O'Connor | 8ebb33b | 2017-05-16 11:47:27 -0400 | [diff] [blame] | 273 | u8 val = inb(PORT_A20), a20_enabled = (val & A20_ENABLE_BIT) != 0; |
| 274 | if (a20_enabled != !!cond) |
| 275 | outb(val ^ A20_ENABLE_BIT, PORT_A20); |
| 276 | return a20_enabled; |
Kevin O'Connor | 341f8d9 | 2014-10-11 13:16:12 -0400 | [diff] [blame] | 277 | } |
| 278 | |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 279 | // x86.c |
| 280 | void cpuid(u32 index, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx); |
| 281 | |
Kevin O'Connor | b9c6a96 | 2013-09-14 13:01:30 -0400 | [diff] [blame] | 282 | #endif // !__ASSEMBLY__ |
| 283 | |
| 284 | #endif // x86.h |