com32/include/x86/cpu.h

   1 #ifndef _X86_CPU_H
   2 #define _X86_CPU_H
   3
   4 #include <klibc/compiler.h>
   5 #include <inttypes.h>
   6 #include <stdbool.h>
   7 #include <x86/regs.h>
   8
   9 static inline __constfunc unsigned long cpu_has_eflags(unsigned long flags)
  10 {
  11     unsigned long f1, f2;
  12
  13     if (__builtin_constant_p(flags)) {
  14         if (!(flags & ~(unsigned long)KNOWN_EFLAGS))
  15             return flags;       /* We know we have them all */
  16     }
  17
  18     asm("pushf ; "
  19         "pushf ; "
  20         "pop %0 ; "
  21         "mov %0,%1 ; "
  22         "xor %2,%1 ; "
  23         "push %1 ; "
  24         "popf ; "
  25         "pushf ; "
  26         "pop %1 ; "
  27         "popf"
  28         : "=&r" (f1), "=&r" (f2) : "ri" (flags));
  29
  30     return (f1 ^ f2) & flags;
  31 }
  32
  33 static inline __constfunc bool cpu_has_eflag(unsigned long flag)
  34 {
  35     return cpu_has_eflags(flag) != 0;
  36 }
  37
  38 static inline uint64_t rdtsc(void)
  39 {
  40     uint32_t eax, edx;
  41     asm volatile("rdtsc" : "=a" (eax), "=d" (edx));
  42     return eax + ((uint64_t)edx << 32);
  43 }
  44
  45 static inline uint32_t rdtscl(void)
  46 {
  47     uint32_t v;
  48     asm volatile("rdtsc" : "=a" (v) : : "edx");
  49     return v;
  50 }
  51
  52 static inline void cpuid_count(uint32_t op, uint32_t cnt,
  53                                uint32_t *eax, uint32_t *ebx,
  54                                uint32_t *ecx, uint32_t *edx)
  55 {
  56 #if defined(__i386__) && defined(__PIC__)
  57     asm volatile("movl %%ebx,%1 ; "
  58                  "cpuid ; "
  59                  "xchgl %1,%%ebx"
  60                  : "=a" (*eax), "=SD" (*ebx), "=c" (*ecx), "=d" (*edx)
  61                  : "a"(op), "c"(cnt));
  62 #else
  63     asm volatile("cpuid"
  64                  : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
  65                  : "a"(op), "c"(cnt));
  66 #endif
  67 }
  68
  69 static inline void cpuid(uint32_t op,
  70                          uint32_t *eax, uint32_t *ebx,
  71                          uint32_t *ecx, uint32_t *edx)
  72 {
  73     cpuid_count(op, 0, eax, ebx, ecx, edx);
  74 }
  75
  76 static inline __constfunc uint32_t cpuid_eax(uint32_t level)
  77 {
  78     uint32_t eax, ebx, ecx, edx;
  79
  80     cpuid_count(level, 0, &eax, &ebx, &ecx, &edx);
  81     return eax;
  82 }
  83
  84 static inline __constfunc uint32_t cpuid_ebx(uint32_t level)
  85 {
  86     uint32_t eax, ebx, ecx, edx;
  87
  88     cpuid_count(level, 0, &eax, &ebx, &ecx, &edx);
  89     return ebx;
  90 }
  91
  92 static inline __constfunc uint32_t cpuid_ecx(uint32_t level)
  93 {
  94     uint32_t eax, ebx, ecx, edx;
  95
  96     cpuid_count(level, 0, &eax, &ebx, &ecx, &edx);
  97     return ecx;
  98 }
  99
 100 static inline __constfunc uint32_t cpuid_edx(uint32_t level)
 101 {
 102     uint32_t eax, ebx, ecx, edx;
 103
 104     cpuid_count(level, 0, &eax, &ebx, &ecx, &edx);
 105     return edx;
 106 }
 107
 108 static inline uint64_t rdmsr(uint32_t msr)
 109 {
 110     uint32_t eax, edx;
 111
 112     asm volatile("rdmsr" : "=a" (eax), "=d" (edx) : "c" (msr));
 113     return eax + ((uint64_t)edx << 32);
 114 }
 115
 116 static inline void wrmsr(uint64_t v, uint32_t msr)
 117 {
 118     uint32_t eax = v;
 119     uint32_t edx = v >> 32;
 120
 121     asm volatile("wrmsr" : : "a" (eax), "d" (edx), "c" (msr));
 122 }
 123
 124 static inline unsigned long long get_cr0(void)
 125 {
 126     unsigned long v;
 127     asm volatile("mov %%cr0,%0" : "=r" (v));
 128     return v;
 129 }
 130
 131 static inline void set_cr0(unsigned long v)
 132 {
 133     asm volatile("mov %0,%%cr0" : : "r" (v));
 134 }
 135
 136 static inline unsigned long get_cr4(void)
 137 {
 138     unsigned long v;
 139     asm volatile("mov %%cr4,%0" : "=r" (v));
 140     return v;
 141 }
 142
 143 static inline void set_cr4(unsigned long v)
 144 {
 145     asm volatile("mov %0,%%cr4" : : "r" (v));
 146 }
 147
 148 static inline uint32_t get_mxcsr(void)
 149 {
 150     uint32_t v;
 151     asm("stmxcsr %0" : "=m" (v));
 152     return v;
 153 }
 154
 155 static inline void set_mxcsr(uint32_t v)
 156 {
 157     asm volatile("ldmxcsr %0" : : "m" (v));
 158 }
 159
 160 static inline void fninit(void)
 161 {
 162     asm volatile("fninit");
 163 }
 164
 165 static inline void cpu_relax(void)
 166 {
 167     asm volatile("rep ; nop");
 168 }
 169
 170 static inline void hlt(void)
 171 {
 172     asm volatile("hlt" : : : "memory");
 173 }
 174
 175 static inline void cli(void)
 176 {
 177     asm volatile("cli" : : : "memory");
 178 }
 179
 180 static inline void sti(void)
 181 {
 182     asm volatile("sti" : : : "memory");
 183 }
 184
 185 static inline unsigned long get_eflags(void)
 186 {
 187     unsigned long v;
 188
 189     asm volatile("pushf ; pop %0" : "=rm" (v));
 190     return v;
 191 }
 192
 193 static inline void set_eflags(unsigned long v)
 194 {
 195     asm volatile("push %0 ; popf" : : "g" (v) : "memory");
 196 }
 197
 198 typedef unsigned long irq_state_t;
 199
 200 static inline irq_state_t irq_state(void)
 201 {
 202     return get_eflags();
 203 }
 204
 205 static inline irq_state_t irq_save(void)
 206 {
 207     irq_state_t v = irq_state();
 208     cli();
 209     return v;
 210 }
 211
 212 static inline void irq_restore(irq_state_t v)
 213 {
 214     set_eflags(v);
 215 }
 216
 217 #endif /* _X86_CPU_H */