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