arch/x86/include/asm/cpu.h

   1 /*
   2  * Copyright (c) 2014 The Chromium OS Authors.
   3  *
   4  * Part of this file is adapted from coreboot
   5  * src/arch/x86/include/arch/cpu.h and
   6  * src/arch/x86/lib/cpu.c
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #ifndef _ASM_CPU_H
  12 #define _ASM_CPU_H
  13
  14 enum {
  15         X86_VENDOR_INVALID = 0,
  16         X86_VENDOR_INTEL,
  17         X86_VENDOR_CYRIX,
  18         X86_VENDOR_AMD,
  19         X86_VENDOR_UMC,
  20         X86_VENDOR_NEXGEN,
  21         X86_VENDOR_CENTAUR,
  22         X86_VENDOR_RISE,
  23         X86_VENDOR_TRANSMETA,
  24         X86_VENDOR_NSC,
  25         X86_VENDOR_SIS,
  26         X86_VENDOR_ANY = 0xfe,
  27         X86_VENDOR_UNKNOWN = 0xff
  28 };
  29
  30 /* Global descriptor table (GDT) bits */
  31 enum {
  32         GDT_4KB                 = 1ULL << 55,
  33         GDT_32BIT               = 1ULL << 54,
  34         GDT_LONG                = 1ULL << 53,
  35         GDT_PRESENT             = 1ULL << 47,
  36         GDT_NOTSYS              = 1ULL << 44,
  37         GDT_CODE                = 1ULL << 43,
  38         GDT_LIMIT_LOW_SHIFT     = 0,
  39         GDT_LIMIT_LOW_MASK      = 0xffff,
  40         GDT_LIMIT_HIGH_SHIFT    = 48,
  41         GDT_LIMIT_HIGH_MASK     = 0xf,
  42         GDT_BASE_LOW_SHIFT      = 16,
  43         GDT_BASE_LOW_MASK       = 0xffff,
  44         GDT_BASE_HIGH_SHIFT     = 56,
  45         GDT_BASE_HIGH_MASK      = 0xf,
  46 };
  47
  48 /*
  49  * System controllers in an x86 system. We mostly need to just find these and
  50  * use them on PCI. At some point these might have their own uclass (e.g.
  51  * UCLASS_VIDEO for the GMA device).
  52  */
  53 enum {
  54         X86_NONE,
  55         X86_SYSCON_ME,          /* Intel Management Engine */
  56         X86_SYSCON_GMA,         /* Intel Graphics Media Accelerator */
  57         X86_SYSCON_PINCONF,     /* Intel x86 pin configuration */
  58 };
  59
  60 struct cpuid_result {
  61         uint32_t eax;
  62         uint32_t ebx;
  63         uint32_t ecx;
  64         uint32_t edx;
  65 };
  66
  67 /*
  68  * Generic CPUID function
  69  */
  70 static inline struct cpuid_result cpuid(int op)
  71 {
  72         struct cpuid_result result;
  73         asm volatile(
  74                 "mov %%ebx, %%edi;"
  75                 "cpuid;"
  76                 "mov %%ebx, %%esi;"
  77                 "mov %%edi, %%ebx;"
  78                 : "=a" (result.eax),
  79                   "=S" (result.ebx),
  80                   "=c" (result.ecx),
  81                   "=d" (result.edx)
  82                 : "0" (op)
  83                 : "edi");
  84         return result;
  85 }
  86
  87 /*
  88  * Generic Extended CPUID function
  89  */
  90 static inline struct cpuid_result cpuid_ext(int op, unsigned ecx)
  91 {
  92         struct cpuid_result result;
  93         asm volatile(
  94                 "mov %%ebx, %%edi;"
  95                 "cpuid;"
  96                 "mov %%ebx, %%esi;"
  97                 "mov %%edi, %%ebx;"
  98                 : "=a" (result.eax),
  99                   "=S" (result.ebx),
 100                   "=c" (result.ecx),
 101                   "=d" (result.edx)
 102                 : "0" (op), "2" (ecx)
 103                 : "edi");
 104         return result;
 105 }
 106
 107 /*
 108  * CPUID functions returning a single datum
 109  */
 110 static inline unsigned int cpuid_eax(unsigned int op)
 111 {
 112         unsigned int eax;
 113
 114         __asm__("mov %%ebx, %%edi;"
 115                 "cpuid;"
 116                 "mov %%edi, %%ebx;"
 117                 : "=a" (eax)
 118                 : "0" (op)
 119                 : "ecx", "edx", "edi");
 120         return eax;
 121 }
 122
 123 static inline unsigned int cpuid_ebx(unsigned int op)
 124 {
 125         unsigned int eax, ebx;
 126
 127         __asm__("mov %%ebx, %%edi;"
 128                 "cpuid;"
 129                 "mov %%ebx, %%esi;"
 130                 "mov %%edi, %%ebx;"
 131                 : "=a" (eax), "=S" (ebx)
 132                 : "0" (op)
 133                 : "ecx", "edx", "edi");
 134         return ebx;
 135 }
 136
 137 static inline unsigned int cpuid_ecx(unsigned int op)
 138 {
 139         unsigned int eax, ecx;
 140
 141         __asm__("mov %%ebx, %%edi;"
 142                 "cpuid;"
 143                 "mov %%edi, %%ebx;"
 144                 : "=a" (eax), "=c" (ecx)
 145                 : "0" (op)
 146                 : "edx", "edi");
 147         return ecx;
 148 }
 149
 150 static inline unsigned int cpuid_edx(unsigned int op)
 151 {
 152         unsigned int eax, edx;
 153
 154         __asm__("mov %%ebx, %%edi;"
 155                 "cpuid;"
 156                 "mov %%edi, %%ebx;"
 157                 : "=a" (eax), "=d" (edx)
 158                 : "0" (op)
 159                 : "ecx", "edi");
 160         return edx;
 161 }
 162
 163 /* Standard macro to see if a specific flag is changeable */
 164 static inline int flag_is_changeable_p(uint32_t flag)
 165 {
 166         uint32_t f1, f2;
 167
 168         asm(
 169                 "pushfl\n\t"
 170                 "pushfl\n\t"
 171                 "popl %0\n\t"
 172                 "movl %0,%1\n\t"
 173                 "xorl %2,%0\n\t"
 174                 "pushl %0\n\t"
 175                 "popfl\n\t"
 176                 "pushfl\n\t"
 177                 "popl %0\n\t"
 178                 "popfl\n\t"
 179                 : "=&r" (f1), "=&r" (f2)
 180                 : "ir" (flag));
 181         return ((f1^f2) & flag) != 0;
 182 }
 183
 184 static inline void mfence(void)
 185 {
 186         __asm__ __volatile__("mfence" : : : "memory");
 187 }
 188
 189 /**
 190  * cpu_enable_paging_pae() - Enable PAE-paging
 191  *
 192  * @cr3:        Value to set in cr3 (PDPT or PML4T)
 193  */
 194 void cpu_enable_paging_pae(ulong cr3);
 195
 196 /**
 197  * cpu_disable_paging_pae() - Disable paging and PAE
 198  */
 199 void cpu_disable_paging_pae(void);
 200
 201 /**
 202  * cpu_has_64bit() - Check if the CPU has 64-bit support
 203  *
 204  * @return 1 if this CPU supports long mode (64-bit), 0 if not
 205  */
 206 int cpu_has_64bit(void);
 207
 208 /**
 209  * cpu_vendor_name() - Get CPU vendor name
 210  *
 211  * @vendor:     CPU vendor enumeration number
 212  *
 213  * @return:     Address to hold the CPU vendor name string
 214  */
 215 const char *cpu_vendor_name(int vendor);
 216
 217 #define CPU_MAX_NAME_LEN        49
 218
 219 /**
 220  * cpu_get_name() - Get the name of the current cpu
 221  *
 222  * @name: Place to put name, which must be CPU_MAX_NAME_LEN bytes including
 223  * @return pointer to name, which will likely be a few bytes after the start
 224  * of @name
 225  * \0 terminator
 226  */
 227 char *cpu_get_name(char *name);
 228
 229 /**
 230  * cpu_call64() - Jump to a 64-bit Linux kernel (internal function)
 231  *
 232  * The kernel is uncompressed and the 64-bit entry point is expected to be
 233  * at @target.
 234  *
 235  * This function is used internally - see cpu_jump_to_64bit() for a more
 236  * useful function.
 237  *
 238  * @pgtable:    Address of 24KB area containing the page table
 239  * @setup_base: Pointer to the setup.bin information for the kernel
 240  * @target:     Pointer to the start of the kernel image
 241  */
 242 void cpu_call64(ulong pgtable, ulong setup_base, ulong target);
 243
 244 /**
 245  * cpu_call32() - Jump to a 32-bit entry point
 246  *
 247  * @code_seg32: 32-bit code segment to use (GDT offset, e.g. 0x20)
 248  * @target:     Pointer to the start of the 32-bit U-Boot image/entry point
 249  * @table:      Pointer to start of info table to pass to U-Boot
 250  */
 251 void cpu_call32(ulong code_seg32, ulong target, ulong table);
 252
 253 /**
 254  * cpu_jump_to_64bit() - Jump to a 64-bit Linux kernel
 255  *
 256  * The kernel is uncompressed and the 64-bit entry point is expected to be
 257  * at @target.
 258  *
 259  * @setup_base: Pointer to the setup.bin information for the kernel
 260  * @target:     Pointer to the start of the kernel image
 261  */
 262 int cpu_jump_to_64bit(ulong setup_base, ulong target);
 263
 264 /**
 265  * cpu_get_family_model() - Get the family and model for the CPU
 266  *
 267  * @return the CPU ID masked with 0x0fff0ff0
 268  */
 269 u32 cpu_get_family_model(void);
 270
 271 /**
 272  * cpu_get_stepping() - Get the stepping value for the CPU
 273  *
 274  * @return the CPU ID masked with 0xf
 275  */
 276 u32 cpu_get_stepping(void);
 277
 278 /**
 279  * cpu_run_reference_code() - Run the platform reference code
 280  *
 281  * Some platforms require a binary blob to be executed once SDRAM is
 282  * available. This is used to set up various platform features, such as the
 283  * platform controller hub (PCH). This function should be implemented by the
 284  * CPU-specific code.
 285  *
 286  * @return 0 on success, -ve on failure
 287  */
 288 int cpu_run_reference_code(void);
 289
 290 #endif