git.ozlabs.org Git - ccan/blob - ccan/cpuid/cpuid.c

   1 /*
   2  * Copyright (c) 2013 Ahmed Samy  <f.fallen45@gmail.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * This file has been written with some help from wikipedia:
  23  *      http://en.wikipedia.org/wiki/CPUID
  24  */
  25
  26 /* Only compile this file if we're on a x86 machine.  */
  27 #if defined(__i386__) || defined(__i386) || defined(__x86_64) \
  28         || defined(_M_AMD64) || defined(__M_X64)
  29 #include "cpuid.h"
  30
  31 #include <string.h>
  32
  33 enum {
  34         CPU_PROC_BRAND_STRING_INTERNAL0                 = 0x80000003,
  35         CPU_PROC_BRAND_STRING_INTERNAL1                 = 0x80000004
  36 };
  37
  38 #ifndef _MSC_VER
  39 static void ___cpuid(cpuid_t info, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
  40 {
  41         __asm__(
  42                 "xchg %%ebx, %%edi\n\t"         /* 32bit PIC: Don't clobber ebx.  */
  43                 "cpuid\n\t"
  44                 "xchg %%ebx, %%edi\n\t"
  45                 : "=a"(*eax), "=D"(*ebx), "=c"(*ecx), "=d"(*edx)
  46                 : "0" (info)
  47         );
  48 }
  49 #else
  50 #include <intrin.h>
  51
  52 static void ___cpuid(cpuid_t info, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
  53 {
  54         uint32_t registers[4];
  55         __cpuid(registers, info);
  56
  57         *eax = registers[0];
  58         *ebx = registers[1];
  59         *ecx = registers[2];
  60         *edx = registers[3];
  61 }
  62 #endif
  63
  64 static struct {
  65         uint32_t feature;
  66         uint32_t mask;
  67         bool use_edx;           /* ecx will be used if false.  */
  68 } features[] = {
  69         { CF_MMX,               1 << 23,        true },
  70         { CF_SSE,               1 << 25,        true },
  71         { CF_SSE2,              1 << 26,        true },
  72         { CF_SSE3,              1 << 9,         false },
  73         { CF_FPU,               1 << 0,         true },
  74
  75         { CF_TSC,               1 << 4,         true },
  76         { CF_MSR,               1 << 5,         true },
  77
  78         { CF_SSSE3,             1 << 9,         false },
  79         { CF_AVX,               1 << 28,        false },
  80
  81         /* Extended ones.  */
  82         { CEF_x64,              1 << 30,        true },
  83         { CEF_FPU,              1 << 0,         true },
  84         { CEF_DE,               1 << 2,         true },
  85         { CEF_SYSCALLRET,       1 << 11,        true },
  86         { CEF_CMOV,             1 << 15,        true },
  87
  88         { CEF_SSE4a,            1 << 6,         false },
  89         { CEF_FMA4,             1 << 16,        false },
  90         { CEF_XOP,              1 << 11,        false }
  91 };
  92
  93 bool cpuid_is_supported(void)
  94 {
  95         int ret = 0;
  96 #if defined(__GNUC__) || defined(__clang__)
  97         /* The following assembly code uses EAX as the return value,
  98          * but we store the value of EAX into ret since GCC uses EAX
  99          * as the return register for every C function.  That's a double
 100          * operation, but there's no other way to do this unless doing this
 101          * function entirely in assembly.
 102          *
 103          * The following assembly code has been shamelessly stolen from:
 104          *      http://wiki.osdev.org/CPUID
 105          * and converted to work with AT&T syntax.
 106          *
 107          * This check is to make sure that the compiler is actually compiling
 108          * for 64-bit.
 109          *
 110          * The compiler can be 32-bit and the system 64-bit so the
 111          * following would be true:
 112          *      #if defined(__x86_64) ...
 113          */
 114
 115 #if UINTPTR_MAX == 0xffffffffffffffff
 116 #define ASM_PUSHF       "pushfq\n\t"
 117 #define ASM_POPF        "popfq\n\t"
 118 #define ASM_PUSHEAX     "pushq %%rax\n\t"
 119 #define ASM_POPEAX      "popq %%rax\n\t"
 120 #define ASM_PUSHECX     "pushq %%rcx\n\t"
 121 #elif UINTPTR_MAX == 0xffffffff
 122 #define ASM_PUSHF       "pushfl\n\t"
 123 #define ASM_POPF        "popfl\n\t"
 124 #define ASM_PUSHEAX     "pushl %%eax\n\t"
 125 #define ASM_POPEAX      "popl %%eax\n\t"
 126 #define ASM_PUSHECX     "pushl %%ecx\n\t"
 127 #endif
 128
 129         asm volatile(
 130                 ASM_PUSHF
 131                 ASM_POPEAX
 132                 "movl %%eax, %%ecx\n\t"
 133                 "xorl $0x200000, %%eax\n\t"
 134                 ASM_PUSHEAX
 135                 ASM_POPF
 136                 ASM_PUSHF
 137                 ASM_POPEAX
 138                 "xorl %%ecx, %%eax\n\t"
 139                 "shrl $21, %%eax\n\t"
 140                 "andl $1, %%eax\n\t"
 141                 ASM_PUSHECX
 142                 ASM_POPF
 143                 : "=a" (ret)
 144         );
 145
 146 #undef ASM_PUSHF
 147 #undef ASM_POPF
 148 #undef ASM_PUSHEAX
 149 #undef ASM_POPEAX
 150 #undef ASM_PUSHECX
 151 #elif defined _MSC_VER
 152         __asm {
 153                 pushfd
 154                 pop eax
 155                 mov ecx, eax
 156                 xor eax, 0x200000
 157                 push eax
 158                 popfd
 159
 160                 pushfd
 161                 pop eax
 162                 xor eax, ecx
 163                 shr eax, 0x21
 164                 and eax, 0x1
 165                 push ecx
 166                 popfd
 167
 168                 mov eax, ret
 169         };
 170 #endif
 171         return !!ret;
 172 }
 173
 174 bool cpuid_test_feature(cpuid_t feature)
 175 {
 176         if (feature > CPU_VIRT_PHYS_ADDR_SIZES || feature < CPU_EXTENDED_PROC_INFO_FEATURE_BITS)
 177                 return false;
 178
 179         return (feature <= cpuid_highest_ext_func_supported());
 180 }
 181
 182 bool cpuid_has_feature(int feature, bool extended)
 183 {
 184         uint32_t eax, ebx, ecx, edx, i;
 185
 186         if (!extended)
 187                 ___cpuid(CPU_PROCINFO_AND_FEATUREBITS, &eax, &ebx, &ecx, &edx);
 188         else
 189                 ___cpuid(CPU_EXTENDED_PROC_INFO_FEATURE_BITS, &eax, &ebx, &ecx, &edx);
 190
 191         for (i = 0; i < sizeof(features) / sizeof(features[0]); ++i) {
 192                 if (features[i].feature == feature) {
 193                         if (features[i].use_edx)
 194                                 return (edx & features[i].mask);
 195                         else
 196                                 return (ecx & features[i].mask);
 197                 }
 198         }
 199         return false;
 200 }
 201
 202 static const char *const cpuids[] = {
 203         "Nooooooooone",
 204         "AMDisbetter!",
 205         "AuthenticAMD",
 206         "CentaurHauls",
 207         "CyrixInstead",
 208         "GenuineIntel",
 209         "TransmetaCPU",
 210         "GeniuneTMx86",
 211         "Geode by NSC",
 212         "NexGenDriven",
 213         "RiseRiseRise",
 214         "SiS SiS SiS ",
 215         "UMC UMC UMC ",
 216         "VIA VIA VIA ",
 217         "Vortex86 SoC",
 218         "KVMKVMKVMKVM"
 219 };
 220
 221 cputype_t cpuid_get_cpu_type(void)
 222 {
 223         static cputype_t cputype;
 224         if (cputype == CT_NONE) {
 225                 union {
 226                         char buf[12];
 227                         uint32_t bufu32[3];
 228                 } u;
 229                 uint32_t i;
 230
 231                 ___cpuid(CPU_VENDORID, &i, &u.bufu32[0], &u.bufu32[2], &u.bufu32[1]);
 232                 for (i = 0; i < sizeof(cpuids) / sizeof(cpuids[0]); ++i) {
 233                         if (strncmp(cpuids[i], u.buf, 12) == 0) {
 234                                 cputype = (cputype_t)i;
 235                                 break;
 236                         }
 237                 }
 238         }
 239
 240         return cputype;
 241 }
 242
 243 bool cpuid_sprintf_cputype(const cputype_t cputype, char *buf)
 244 {
 245         if (cputype == CT_NONE)
 246                 return false;
 247
 248         memcpy(buf, cpuids[(int)cputype], 12);
 249         buf[12] = '\0';
 250         return true;
 251 }
 252
 253 uint32_t cpuid_highest_ext_func_supported(void)
 254 {
 255         static uint32_t highest;
 256
 257         if (!highest) {
 258 #if defined(__GNUC__) || defined(__clang__)
 259                 asm volatile(
 260                         "cpuid\n\t"
 261                         : "=a" (highest)
 262                         : "a" (CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED)
 263                 );
 264 #elif defined _MSC_VER
 265                 __asm {
 266                         mov eax, CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED
 267                         cpuid
 268                         mov highest, eax
 269                 };
 270 #endif
 271         }
 272
 273         return highest;
 274 }
 275
 276 void cpuid(cpuid_t info, uint32_t *buf)
 277 {
 278         /* Sanity checks, make sure we're not trying to do something
 279          * invalid or we are trying to get information that isn't supported
 280          * by the CPU.  */
 281         if (info > CPU_VIRT_PHYS_ADDR_SIZES || (info > CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED
 282                 && !cpuid_test_feature(info)))
 283                 return;
 284
 285         if (info == CPU_PROC_BRAND_STRING) {
 286                 static char cached[48] = { 0 };
 287                 if (cached[0] == '\0') {
 288                         ___cpuid(CPU_PROC_BRAND_STRING,           &buf[0], &buf[1], &buf[2],  &buf[3]);
 289                         ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL0, &buf[4], &buf[5], &buf[6],  &buf[7]);
 290                         ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL1, &buf[8], &buf[9], &buf[10], &buf[11]);
 291
 292                         memcpy(cached, buf, sizeof cached);
 293                 } else
 294                         buf = (uint32_t *)cached;
 295
 296                 return;
 297         } else if (info == CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED) {
 298                 *buf = cpuid_highest_ext_func_supported();
 299                 return;
 300         }
 301
 302         uint32_t eax, ebx, ecx, edx;
 303         ___cpuid(info, &eax, &ebx, &ecx, &edx);
 304
 305         switch (info) {
 306                 case CPU_VENDORID:
 307                         buf[0] = ebx;
 308                         buf[1] = edx;
 309                         buf[2] = ecx;
 310                         break;
 311                 case CPU_PROCINFO_AND_FEATUREBITS:
 312                         buf[0] = (eax & 0x0F);          /* Stepping  */
 313                         buf[1] = (eax >> 4)  & 0x0F;    /* Model  */
 314                         buf[2] = (eax >> 8)  & 0x0F;    /* Family  */
 315                         buf[3] = (eax >> 16) & 0x0F;    /* Extended Model.  */
 316                         buf[4] = (eax >> 24) & 0x0F;    /* Extended Family.  */
 317
 318                         buf[5] = edx;                   /* Feature flags #1.  */
 319                         buf[6] = ecx;                   /* Feature flags #2.  */
 320
 321                         /* Additional Feature information.  */
 322                         buf[7] = ebx & 0xFF;
 323                         buf[8] = (ebx >> 8) & 0xFF;
 324                         buf[9] = (ebx >> 16) & 0xFF;
 325                         buf[10] = (ebx >> 24) & 0xFF;
 326                         break;
 327                 case CPU_CACHE_AND_TLBD_INFO:
 328                         buf[0] = eax;
 329                         buf[1] = ebx;
 330                         buf[2] = ecx;
 331                         buf[3] = edx;
 332                         break;
 333                 case CPU_EXTENDED_PROC_INFO_FEATURE_BITS:
 334                         buf[0] = edx;
 335                         buf[1] = ecx;
 336                         break;
 337                 case CPU_L1_CACHE_AND_TLB_IDS:
 338                         buf[0] = eax;
 339                         buf[1] = ebx;
 340                         buf[2] = ecx;
 341                         buf[3] = edx;
 342                         break;
 343                 case CPU_EXTENDED_L2_CACHE_FEATURES:
 344                         buf[0] = ecx & 0xFF;            /* Line size.  */
 345                         buf[1] = (ecx >> 12) & 0xFF;    /* Associativity.  */
 346                         buf[2] = ecx >> 16;             /* Cache size.  */
 347                         break;
 348                 case CPU_ADV_POWER_MGT_INFO:
 349                         *buf = edx;
 350                         break;
 351                 case CPU_VIRT_PHYS_ADDR_SIZES:
 352                         buf[0] = eax & 0xFF;            /* physical.  */
 353                         buf[1] = (eax >> 8) & 0xFF;     /* virtual.  */
 354                         break;
 355                 default:
 356                         *buf = 0xbaadf00d;
 357                         break;
 358         }
 359 }
 360
 361 #endif