cpuid: cache processor brand string
[ccan] / 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         /* The following assembly code uses EAX as the return value,
96          * but we store the value of EAX into ret since GCC uses EAX
97          * as the return register for every C function.  That's a double
98          * operation, but there's no other way to do this unless doing this
99          * function entirely in assembly.  */
100
101         /* This check is to make sure that the compiler is actually compiling
102          * for 64-bit.
103          *
104          * The compiler can be 32-bit and the system 64-bit so the 
105          * following would be true:
106          *      #if defined(__x86_64) ...
107          */
108
109 #if UINTPTR_MAX == 0xffffffffffffffff
110 #define ASM_PUSHF       "pushfq\n\t"
111 #define ASM_POPF        "popfq\n\t"
112 #define ASM_PUSHEAX     "pushq %%rax\n\t"
113 #define ASM_POPEAX      "popq %%rax\n\t"
114 #define ASM_PUSHECX     "popq %%rcx\n\t"
115 #elif UINTPTR_MAX == 0xffffffff
116 #define ASM_PUSHF       "pushfl\n\t"
117 #define ASM_POPF        "popfl\n\t"
118 #define ASM_PUSHEAX     "pushl %%eax\n\t"
119 #define ASM_POPEAX      "popl %%eax\n\t"
120 #define ASM_PUSHECX     "popl %%ecx\n\t"
121 #endif
122
123         int ret = 0;
124         asm volatile(
125                 ASM_PUSHF
126                 ASM_POPEAX
127                 "movl %%eax, %%ecx\n\t"
128                 "xorl $0x200000, %%eax\n\t"
129                 ASM_PUSHEAX
130                 ASM_POPF
131                 ASM_PUSHF
132                 ASM_POPEAX
133                 "xorl %%ecx, %%eax\n\t"
134                 "shrl $21, %%eax\n\t"
135                 "andl $1, %%eax\n\t"
136                 ASM_PUSHECX
137                 ASM_POPF
138                 : "=a" (ret)
139         );
140
141 #undef ASM_PUSHF
142 #undef ASM_POPF
143 #undef ASM_PUSHEAX
144 #undef ASM_POPEAX
145 #undef ASM_PUSHECX
146
147         return !!ret;
148 }
149
150 bool cpuid_test_feature(cpuid_t feature)
151 {
152         if (feature > CPU_VIRT_PHYS_ADDR_SIZES || feature < CPU_EXTENDED_PROC_INFO_FEATURE_BITS)
153                 return false;
154
155         return (feature <= cpuid_highest_ext_func_supported());
156 }
157
158 bool cpuid_has_feature(int feature, bool extended)
159 {
160         uint32_t eax, ebx, ecx, edx;
161
162         if (!extended)
163                 ___cpuid(CPU_PROCINFO_AND_FEATUREBITS, &eax, &ebx, &ecx, &edx);
164         else
165                 ___cpuid(CPU_EXTENDED_PROC_INFO_FEATURE_BITS, &eax, &ebx, &ecx, &edx);
166
167         for (i = 0; i < sizeof(features) / sizeof(features[0]); ++i) {
168                 if (features[i].feature == feature) {
169                         if (features[i].use_edx)
170                                 return (edx & features[i].mask);
171                         else
172                                 return (ecx & features[i].mask);
173                 }
174         }
175         return false;
176 }
177
178 static const char *const cpuids[] = {
179         "Nooooooooone",
180         "AMDisbetter!",
181         "AuthenticAMD",
182         "CentaurHauls",
183         "CyrixInstead",
184         "GenuineIntel",
185         "TransmetaCPU",
186         "GeniuneTMx86",
187         "Geode by NSC",
188         "NexGenDriven",
189         "RiseRiseRise",
190         "SiS SiS SiS ",
191         "UMC UMC UMC ",
192         "VIA VIA VIA ",
193         "Vortex86 SoC",
194         "KVMKVMKVMKVM"
195 };
196
197 cputype_t cpuid_get_cpu_type(void)
198 {
199         static cputype_t cputype;
200         if (cputype == CT_NONE) {
201                 union {
202                         char buf[12];
203                         uint32_t bufu32[3];
204                 } u;
205                 uint32_t i;
206
207                 ___cpuid(CPU_VENDORID, &i, &u.bufu32[0], &u.bufu32[2], &u.bufu32[1]);
208                 u.buf[12] = '\0';
209
210                 for (i = 0; i < sizeof(cpuids) / sizeof(cpuids[0]); ++i) {
211                         if (strncmp(cpuids[i], u.buf, 12) == 0) {
212                                 cputype = (cputype_t)i;
213                                 break;
214                         }
215                 }
216         }
217
218         return cputype;
219 }
220
221 const char *cpuid_get_cpu_type_string(const cputype_t cputype)
222 {
223         return cpuids[(int)cputype];
224 }
225
226 uint32_t cpuid_highest_ext_func_supported(void)
227 {
228         static uint32_t highest;
229
230         if (!highest) {
231                 asm volatile(
232                         "cpuid\n\t"
233                         : "=a" (highest)
234                         : "a" (CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED)
235                 );
236         }
237
238         return highest;
239 }
240
241 void cpuid(cpuid_t info, uint32_t *buf)
242 {
243         /* Sanity checks, make sure we're not trying to do something
244          * invalid or we are trying to get information that isn't supported
245          * by the CPU.  */
246         if (info > CPU_VIRT_PHYS_ADDR_SIZES || (info > CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED
247                 && !cpuid_test_feature(info)))
248                 return;
249
250         if (info == CPU_PROC_BRAND_STRING) {
251                 static char cached[48] = { 0 };
252                 if (cached[0] == '\0') {
253                         ___cpuid(CPU_PROC_BRAND_STRING,           &buf[0], &buf[1], &buf[2],  &buf[3]);
254                         ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL0, &buf[4], &buf[5], &buf[6],  &buf[7]);
255                         ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL1, &buf[8], &buf[9], &buf[10], &buf[11]);
256
257                         memcpy(cached, buf, sizeof cached);
258                 } else
259                         buf = (uint32_t *)cached;
260
261                 return;
262         } else if (info == CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED) {
263                 *buf = cpuid_highest_ext_func_supported();
264                 return;
265         }
266
267         uint32_t eax, ebx, ecx, edx;
268         ___cpuid(info, &eax, &ebx, &ecx, &edx);
269
270         switch (info) {
271                 case CPU_VENDORID:
272                         buf[0] = ebx;
273                         buf[1] = edx;
274                         buf[2] = ecx;
275                         break;
276                 case CPU_PROCINFO_AND_FEATUREBITS:
277                         buf[0] = eax;   /* The so called "signature" of the CPU.  */
278                         buf[1] = edx;   /* Feature flags #1.  */
279                         buf[2] = ecx;   /* Feature flags #2.  */
280                         buf[3] = ebx;   /* Additional feature information.  */
281                         break;
282                 case CPU_CACHE_AND_TLBD_INFO:
283                         buf[0] = eax;
284                         buf[1] = ebx;
285                         buf[2] = ecx;
286                         buf[3] = edx;
287                         break;
288                 case CPU_EXTENDED_PROC_INFO_FEATURE_BITS:
289                         buf[0] = edx;
290                         buf[1] = ecx;
291                         break;
292                 case CPU_L1_CACHE_AND_TLB_IDS:
293                         buf[0] = eax;
294                         buf[1] = ebx;
295                         buf[2] = ecx;
296                         buf[3] = edx;
297                         break;
298                 case CPU_EXTENDED_L2_CACHE_FEATURES:
299                         *buf = ecx;
300                         break;
301                 case CPU_ADV_POWER_MGT_INFO:
302                         *buf = edx;
303                         break;
304                 case CPU_VIRT_PHYS_ADDR_SIZES:
305                         *buf = eax;
306                         break;
307                 default:
308                         *buf = 0xbaadf00d;
309                         break;
310         }
311 }
312
313 #endif
314