cpuid: prefix every function with cpuid_
[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 #include <stdint.h>
26 #include <string.h>
27
28 #include "cpuid.h"
29
30 enum {
31         CPU_PROC_BRAND_STRING_INTERNAL0                 = 0x80000003,
32         CPU_PROC_BRAND_STRING_INTERNAL1                 = 0x80000004
33 };
34
35 #ifndef _MSC_VER
36 static void ___cpuid(cpuid_t info, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
37 {
38         __asm__(
39                 "xchg %%ebx, %%edi\n\t"         /* 32bit PIC: Don't clobber ebx.  */
40                 "cpuid\n\t"
41                 "xchg %%ebx, %%edi\n\t"
42                 : "=a"(*eax), "=D"(*ebx), "=c"(*ecx), "=d"(*edx)
43                 : "0" (info)
44         );
45 }
46 #else
47 #include <intrin.h>
48
49 static void ___cpuid(cpuid_t info, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
50 {
51         uint32_t registers[4];
52         __cpuid(registers, info);
53
54         *eax = registers[0];
55         *ebx = registers[1];
56         *ecx = registers[2];
57         *edx = registers[3];
58 }
59 #endif
60
61 static struct {
62         int feature;
63         unsigned mask;
64         int instruction;        /* 0 = ecx, 1 = edx.  */
65 } features[] = {
66         { CF_MMX,               1 << 23,        1 },
67         { CF_SSE,               1 << 25,        1 },
68         { CF_SSE2,              1 << 26,        1 },
69         { CF_SSE3,              1 << 9,         0 },
70         { CF_FPU,               1 << 0,         1 },
71
72         { CF_TSC,               1 << 4,         1 },
73         { CF_MSR,               1 << 5,         1 },
74
75         { CF_SSSE3,             1 << 9,         0 },
76         { CF_AVX,               1 << 28,        0 },
77
78         /* Extended ones.  */
79         { CEF_x64,              1 << 30,        1 },
80         { CEF_FPU,              1 << 0,         1 },
81         { CEF_DE,               1 << 2,         1 },
82         { CEF_SYSCALLRET,       1 << 11,        1 },
83         { CEF_CMOV,             1 << 15,        1 },
84
85         { CEF_SSE4a,            1 << 6,         0 },
86         { CEF_FMA4,             1 << 16,        0 },
87         { CEF_XOP,              1 << 11,        0 }
88 };
89
90 static int has_feature(int feature, uint32_t ecx, uint32_t edx)
91 {
92         int i;
93
94         for (i = 0; i < sizeof(features) / sizeof(features[0]); ++i) {
95                 if (features[i].feature == feature) {
96                         if (features[i].instruction == 0)
97                                 return (ecx & features[i].mask);
98                         else
99                                 return (edx & features[i].mask);
100                 }
101         }
102
103         return 0;
104 }
105
106 int cpuid_test_feature(cpuid_t feature)
107 {
108         if (feature > CPU_VIRT_PHYS_ADDR_SIZES || feature < CPU_EXTENDED_PROC_INFO_FEATURE_BITS)
109                 return 0;
110
111         return (feature <= cpuid_highest_ext_func_supported());
112 }
113
114 int cpuid_has_feature(int feature, int extended)
115 {
116         uint32_t eax, ebx, ecx, edx;
117
118         if (extended == 0)
119                 ___cpuid(CPU_PROCINFO_AND_FEATUREBITS, &eax, &ebx, &ecx, &edx);
120         else
121                 ___cpuid(CPU_EXTENDED_PROC_INFO_FEATURE_BITS, &eax, &ebx, &ecx, &edx);
122
123         return has_feature(feature, ecx, edx);
124 }
125
126 static const char *cpuids[] = {
127         "Nooooooooone",
128         "AMDisbetter!",
129         "AuthenticAMD",
130         "CentaurHauls",
131         "CyrixInstead",
132         "GenuineIntel",
133         "TransmetaCPU",
134         "GeniuneTMx86",
135         "Geode by NSC",
136         "NexGenDriven",
137         "RiseRiseRise",
138         "SiS SiS SiS ",
139         "UMC UMC UMC ",
140         "VIA VIA VIA ",
141         "Vortex86 SoC",
142         "KVMKVMKVMKVM"
143 };
144
145 cputype_t cpuid_get_cpu_type(void)
146 {
147         static cputype_t cputype;
148         if (cputype == CT_NONE) {
149                 union {
150                         char buf[12];
151                         uint32_t bufu32[3];
152                 } u;
153                 uint32_t i;
154
155                 ___cpuid(CPU_VENDORID, &i, &u.bufu32[0], &u.bufu32[2], &u.bufu32[1]);
156                 u.buf[12] = '\0';
157
158                 for (i = 0; i < sizeof(cpuids) / sizeof(cpuids[0]); ++i) {
159                         if (strncmp(cpuids[i], u.buf, 12) == 0) {
160                                 cputype = (cputype_t)i;
161                                 break;
162                         }
163                 }
164         }
165
166         return cputype;
167 }
168
169 const char *cpuid_get_cpu_type_string(const cputype_t cputype)
170 {
171         return cpuids[(int)cputype];
172 }
173
174 int cpuid_highest_ext_func_supported(void)
175 {
176         static int highest;
177
178         if (!highest) {
179                 asm volatile(
180                         "cpuid\n\t"
181                         : "=a" (highest)
182                         : "a" (CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED)
183                 );
184         }
185
186         return highest;
187 }
188
189 void cpuid(cpuid_t info, void *buf)
190 {
191         /* Sanity checks, make sure we're not trying to do something
192          * invalid or we are trying to get information that isn't supported
193          * by the CPU.  */
194         if (info > CPU_VIRT_PHYS_ADDR_SIZES || (info > CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED
195                 && !cpuid_test_feature(info)))
196                 return;
197
198         uint32_t *ubuf = buf;
199         if (info == CPU_PROC_BRAND_STRING) {
200                 ___cpuid(CPU_PROC_BRAND_STRING,           &ubuf[0], &ubuf[1], &ubuf[2],  &ubuf[3]);
201                 ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL0, &ubuf[4], &ubuf[5], &ubuf[6],  &ubuf[7]);
202                 ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL1, &ubuf[8], &ubuf[9], &ubuf[10], &ubuf[11]);
203                 return;
204         } else if (info == CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED) {
205                 *ubuf = cpuid_highest_ext_func_supported();
206                 return;
207         }
208
209         uint32_t eax, ebx, ecx, edx;
210         ___cpuid(info, &eax, &ebx, &ecx, &edx);
211
212         switch (info) {
213                 case CPU_VENDORID:
214                         ubuf[0] = ebx;
215                         ubuf[1] = edx;
216                         ubuf[2] = ecx;
217                         break;
218                 case CPU_PROCINFO_AND_FEATUREBITS:
219                         ubuf[0] = eax;  /* The so called "signature" of the CPU.  */
220                         ubuf[1] = edx;  /* Feature flags #1.  */
221                         ubuf[2] = ecx;  /* Feature flags #2.  */
222                         ubuf[3] = ebx;  /* Additional feature information.  */
223                         break;
224                 case CPU_CACHE_AND_TLBD_INFO:
225                         ubuf[0] = eax;
226                         ubuf[1] = ebx;
227                         ubuf[2] = ecx;
228                         ubuf[3] = edx;
229                         break;
230                 case CPU_EXTENDED_PROC_INFO_FEATURE_BITS:
231                         ubuf[0] = edx;
232                         ubuf[1] = ecx;
233                         break;
234                 case CPU_L1_CACHE_AND_TLB_IDS:
235                         break;
236                 case CPU_EXTENDED_L2_CACHE_FEATURES:
237                         *ubuf = ecx;
238                         break;
239                 case CPU_ADV_POWER_MGT_INFO:
240                         *ubuf = edx;
241                         break;
242                 case CPU_VIRT_PHYS_ADDR_SIZES:
243                         *ubuf = eax;
244                         break;
245                 default:
246                         *ubuf = 0xbaadf00d;
247                         break;
248         }
249 }
250