ff663ca63fdc24353532280f1f55a4a87b0fd1d7
[linux-2.6.git] / arch / x86 / kernel / cpu / intel_cacheinfo.c
1 /*
2  *      Routines to indentify caches on Intel CPU.
3  *
4  *      Changes:
5  *      Venkatesh Pallipadi     : Adding cache identification through cpuid(4)
6  *      Ashok Raj <ashok.raj@intel.com>: Work with CPU hotplug infrastructure.
7  *      Andi Kleen / Andreas Herrmann   : CPUID4 emulation on AMD.
8  */
9
10 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/device.h>
13 #include <linux/compiler.h>
14 #include <linux/cpu.h>
15 #include <linux/sched.h>
16 #include <linux/pci.h>
17
18 #include <asm/processor.h>
19 #include <linux/smp.h>
20 #include <asm/k8.h>
21 #include <asm/smp.h>
22
23 #define LVL_1_INST      1
24 #define LVL_1_DATA      2
25 #define LVL_2           3
26 #define LVL_3           4
27 #define LVL_TRACE       5
28
29 struct _cache_table {
30         unsigned char descriptor;
31         char cache_type;
32         short size;
33 };
34
35 #define MB(x)   ((x) * 1024)
36
37 /* All the cache descriptor types we care about (no TLB or
38    trace cache entries) */
39
40 static const struct _cache_table __cpuinitconst cache_table[] =
41 {
42         { 0x06, LVL_1_INST, 8 },        /* 4-way set assoc, 32 byte line size */
43         { 0x08, LVL_1_INST, 16 },       /* 4-way set assoc, 32 byte line size */
44         { 0x09, LVL_1_INST, 32 },       /* 4-way set assoc, 64 byte line size */
45         { 0x0a, LVL_1_DATA, 8 },        /* 2 way set assoc, 32 byte line size */
46         { 0x0c, LVL_1_DATA, 16 },       /* 4-way set assoc, 32 byte line size */
47         { 0x0d, LVL_1_DATA, 16 },       /* 4-way set assoc, 64 byte line size */
48         { 0x21, LVL_2,      256 },      /* 8-way set assoc, 64 byte line size */
49         { 0x22, LVL_3,      512 },      /* 4-way set assoc, sectored cache, 64 byte line size */
50         { 0x23, LVL_3,      MB(1) },    /* 8-way set assoc, sectored cache, 64 byte line size */
51         { 0x25, LVL_3,      MB(2) },    /* 8-way set assoc, sectored cache, 64 byte line size */
52         { 0x29, LVL_3,      MB(4) },    /* 8-way set assoc, sectored cache, 64 byte line size */
53         { 0x2c, LVL_1_DATA, 32 },       /* 8-way set assoc, 64 byte line size */
54         { 0x30, LVL_1_INST, 32 },       /* 8-way set assoc, 64 byte line size */
55         { 0x39, LVL_2,      128 },      /* 4-way set assoc, sectored cache, 64 byte line size */
56         { 0x3a, LVL_2,      192 },      /* 6-way set assoc, sectored cache, 64 byte line size */
57         { 0x3b, LVL_2,      128 },      /* 2-way set assoc, sectored cache, 64 byte line size */
58         { 0x3c, LVL_2,      256 },      /* 4-way set assoc, sectored cache, 64 byte line size */
59         { 0x3d, LVL_2,      384 },      /* 6-way set assoc, sectored cache, 64 byte line size */
60         { 0x3e, LVL_2,      512 },      /* 4-way set assoc, sectored cache, 64 byte line size */
61         { 0x3f, LVL_2,      256 },      /* 2-way set assoc, 64 byte line size */
62         { 0x41, LVL_2,      128 },      /* 4-way set assoc, 32 byte line size */
63         { 0x42, LVL_2,      256 },      /* 4-way set assoc, 32 byte line size */
64         { 0x43, LVL_2,      512 },      /* 4-way set assoc, 32 byte line size */
65         { 0x44, LVL_2,      MB(1) },    /* 4-way set assoc, 32 byte line size */
66         { 0x45, LVL_2,      MB(2) },    /* 4-way set assoc, 32 byte line size */
67         { 0x46, LVL_3,      MB(4) },    /* 4-way set assoc, 64 byte line size */
68         { 0x47, LVL_3,      MB(8) },    /* 8-way set assoc, 64 byte line size */
69         { 0x49, LVL_3,      MB(4) },    /* 16-way set assoc, 64 byte line size */
70         { 0x4a, LVL_3,      MB(6) },    /* 12-way set assoc, 64 byte line size */
71         { 0x4b, LVL_3,      MB(8) },    /* 16-way set assoc, 64 byte line size */
72         { 0x4c, LVL_3,      MB(12) },   /* 12-way set assoc, 64 byte line size */
73         { 0x4d, LVL_3,      MB(16) },   /* 16-way set assoc, 64 byte line size */
74         { 0x4e, LVL_2,      MB(6) },    /* 24-way set assoc, 64 byte line size */
75         { 0x60, LVL_1_DATA, 16 },       /* 8-way set assoc, sectored cache, 64 byte line size */
76         { 0x66, LVL_1_DATA, 8 },        /* 4-way set assoc, sectored cache, 64 byte line size */
77         { 0x67, LVL_1_DATA, 16 },       /* 4-way set assoc, sectored cache, 64 byte line size */
78         { 0x68, LVL_1_DATA, 32 },       /* 4-way set assoc, sectored cache, 64 byte line size */
79         { 0x70, LVL_TRACE,  12 },       /* 8-way set assoc */
80         { 0x71, LVL_TRACE,  16 },       /* 8-way set assoc */
81         { 0x72, LVL_TRACE,  32 },       /* 8-way set assoc */
82         { 0x73, LVL_TRACE,  64 },       /* 8-way set assoc */
83         { 0x78, LVL_2,      MB(1) },    /* 4-way set assoc, 64 byte line size */
84         { 0x79, LVL_2,      128 },      /* 8-way set assoc, sectored cache, 64 byte line size */
85         { 0x7a, LVL_2,      256 },      /* 8-way set assoc, sectored cache, 64 byte line size */
86         { 0x7b, LVL_2,      512 },      /* 8-way set assoc, sectored cache, 64 byte line size */
87         { 0x7c, LVL_2,      MB(1) },    /* 8-way set assoc, sectored cache, 64 byte line size */
88         { 0x7d, LVL_2,      MB(2) },    /* 8-way set assoc, 64 byte line size */
89         { 0x7f, LVL_2,      512 },      /* 2-way set assoc, 64 byte line size */
90         { 0x82, LVL_2,      256 },      /* 8-way set assoc, 32 byte line size */
91         { 0x83, LVL_2,      512 },      /* 8-way set assoc, 32 byte line size */
92         { 0x84, LVL_2,      MB(1) },    /* 8-way set assoc, 32 byte line size */
93         { 0x85, LVL_2,      MB(2) },    /* 8-way set assoc, 32 byte line size */
94         { 0x86, LVL_2,      512 },      /* 4-way set assoc, 64 byte line size */
95         { 0x87, LVL_2,      MB(1) },    /* 8-way set assoc, 64 byte line size */
96         { 0xd0, LVL_3,      512 },      /* 4-way set assoc, 64 byte line size */
97         { 0xd1, LVL_3,      MB(1) },    /* 4-way set assoc, 64 byte line size */
98         { 0xd2, LVL_3,      MB(2) },    /* 4-way set assoc, 64 byte line size */
99         { 0xd6, LVL_3,      MB(1) },    /* 8-way set assoc, 64 byte line size */
100         { 0xd7, LVL_3,      MB(2) },    /* 8-way set assoc, 64 byte line size */
101         { 0xd8, LVL_3,      MB(4) },    /* 12-way set assoc, 64 byte line size */
102         { 0xdc, LVL_3,      MB(2) },    /* 12-way set assoc, 64 byte line size */
103         { 0xdd, LVL_3,      MB(4) },    /* 12-way set assoc, 64 byte line size */
104         { 0xde, LVL_3,      MB(8) },    /* 12-way set assoc, 64 byte line size */
105         { 0xe2, LVL_3,      MB(2) },    /* 16-way set assoc, 64 byte line size */
106         { 0xe3, LVL_3,      MB(4) },    /* 16-way set assoc, 64 byte line size */
107         { 0xe4, LVL_3,      MB(8) },    /* 16-way set assoc, 64 byte line size */
108         { 0xea, LVL_3,      MB(12) },   /* 24-way set assoc, 64 byte line size */
109         { 0xeb, LVL_3,      MB(18) },   /* 24-way set assoc, 64 byte line size */
110         { 0xec, LVL_3,      MB(24) },   /* 24-way set assoc, 64 byte line size */
111         { 0x00, 0, 0}
112 };
113
114
115 enum _cache_type {
116         CACHE_TYPE_NULL = 0,
117         CACHE_TYPE_DATA = 1,
118         CACHE_TYPE_INST = 2,
119         CACHE_TYPE_UNIFIED = 3
120 };
121
122 union _cpuid4_leaf_eax {
123         struct {
124                 enum _cache_type        type:5;
125                 unsigned int            level:3;
126                 unsigned int            is_self_initializing:1;
127                 unsigned int            is_fully_associative:1;
128                 unsigned int            reserved:4;
129                 unsigned int            num_threads_sharing:12;
130                 unsigned int            num_cores_on_die:6;
131         } split;
132         u32 full;
133 };
134
135 union _cpuid4_leaf_ebx {
136         struct {
137                 unsigned int            coherency_line_size:12;
138                 unsigned int            physical_line_partition:10;
139                 unsigned int            ways_of_associativity:10;
140         } split;
141         u32 full;
142 };
143
144 union _cpuid4_leaf_ecx {
145         struct {
146                 unsigned int            number_of_sets:32;
147         } split;
148         u32 full;
149 };
150
151 struct amd_l3_cache {
152         struct   pci_dev *dev;
153         bool     can_disable;
154         unsigned indices;
155         u8       subcaches[4];
156 };
157
158 struct _cpuid4_info {
159         union _cpuid4_leaf_eax eax;
160         union _cpuid4_leaf_ebx ebx;
161         union _cpuid4_leaf_ecx ecx;
162         unsigned long size;
163         struct amd_l3_cache *l3;
164         DECLARE_BITMAP(shared_cpu_map, NR_CPUS);
165 };
166
167 /* subset of above _cpuid4_info w/o shared_cpu_map */
168 struct _cpuid4_info_regs {
169         union _cpuid4_leaf_eax eax;
170         union _cpuid4_leaf_ebx ebx;
171         union _cpuid4_leaf_ecx ecx;
172         unsigned long size;
173         struct amd_l3_cache *l3;
174 };
175
176 unsigned short                  num_cache_leaves;
177
178 /* AMD doesn't have CPUID4. Emulate it here to report the same
179    information to the user.  This makes some assumptions about the machine:
180    L2 not shared, no SMT etc. that is currently true on AMD CPUs.
181
182    In theory the TLBs could be reported as fake type (they are in "dummy").
183    Maybe later */
184 union l1_cache {
185         struct {
186                 unsigned line_size:8;
187                 unsigned lines_per_tag:8;
188                 unsigned assoc:8;
189                 unsigned size_in_kb:8;
190         };
191         unsigned val;
192 };
193
194 union l2_cache {
195         struct {
196                 unsigned line_size:8;
197                 unsigned lines_per_tag:4;
198                 unsigned assoc:4;
199                 unsigned size_in_kb:16;
200         };
201         unsigned val;
202 };
203
204 union l3_cache {
205         struct {
206                 unsigned line_size:8;
207                 unsigned lines_per_tag:4;
208                 unsigned assoc:4;
209                 unsigned res:2;
210                 unsigned size_encoded:14;
211         };
212         unsigned val;
213 };
214
215 static const unsigned short __cpuinitconst assocs[] = {
216         [1] = 1,
217         [2] = 2,
218         [4] = 4,
219         [6] = 8,
220         [8] = 16,
221         [0xa] = 32,
222         [0xb] = 48,
223         [0xc] = 64,
224         [0xd] = 96,
225         [0xe] = 128,
226         [0xf] = 0xffff /* fully associative - no way to show this currently */
227 };
228
229 static const unsigned char __cpuinitconst levels[] = { 1, 1, 2, 3 };
230 static const unsigned char __cpuinitconst types[] = { 1, 2, 3, 3 };
231
232 static void __cpuinit
233 amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax,
234                      union _cpuid4_leaf_ebx *ebx,
235                      union _cpuid4_leaf_ecx *ecx)
236 {
237         unsigned dummy;
238         unsigned line_size, lines_per_tag, assoc, size_in_kb;
239         union l1_cache l1i, l1d;
240         union l2_cache l2;
241         union l3_cache l3;
242         union l1_cache *l1 = &l1d;
243
244         eax->full = 0;
245         ebx->full = 0;
246         ecx->full = 0;
247
248         cpuid(0x80000005, &dummy, &dummy, &l1d.val, &l1i.val);
249         cpuid(0x80000006, &dummy, &dummy, &l2.val, &l3.val);
250
251         switch (leaf) {
252         case 1:
253                 l1 = &l1i;
254         case 0:
255                 if (!l1->val)
256                         return;
257                 assoc = assocs[l1->assoc];
258                 line_size = l1->line_size;
259                 lines_per_tag = l1->lines_per_tag;
260                 size_in_kb = l1->size_in_kb;
261                 break;
262         case 2:
263                 if (!l2.val)
264                         return;
265                 assoc = assocs[l2.assoc];
266                 line_size = l2.line_size;
267                 lines_per_tag = l2.lines_per_tag;
268                 /* cpu_data has errata corrections for K7 applied */
269                 size_in_kb = current_cpu_data.x86_cache_size;
270                 break;
271         case 3:
272                 if (!l3.val)
273                         return;
274                 assoc = assocs[l3.assoc];
275                 line_size = l3.line_size;
276                 lines_per_tag = l3.lines_per_tag;
277                 size_in_kb = l3.size_encoded * 512;
278                 if (boot_cpu_has(X86_FEATURE_AMD_DCM)) {
279                         size_in_kb = size_in_kb >> 1;
280                         assoc = assoc >> 1;
281                 }
282                 break;
283         default:
284                 return;
285         }
286
287         eax->split.is_self_initializing = 1;
288         eax->split.type = types[leaf];
289         eax->split.level = levels[leaf];
290         eax->split.num_threads_sharing = 0;
291         eax->split.num_cores_on_die = current_cpu_data.x86_max_cores - 1;
292
293
294         if (assoc == 0xffff)
295                 eax->split.is_fully_associative = 1;
296         ebx->split.coherency_line_size = line_size - 1;
297         ebx->split.ways_of_associativity = assoc - 1;
298         ebx->split.physical_line_partition = lines_per_tag - 1;
299         ecx->split.number_of_sets = (size_in_kb * 1024) / line_size /
300                 (ebx->split.ways_of_associativity + 1) - 1;
301 }
302
303 struct _cache_attr {
304         struct attribute attr;
305         ssize_t (*show)(struct _cpuid4_info *, char *);
306         ssize_t (*store)(struct _cpuid4_info *, const char *, size_t count);
307 };
308
309 #ifdef CONFIG_CPU_SUP_AMD
310 static void __cpuinit amd_calc_l3_indices(struct amd_l3_cache *l3)
311 {
312         /*
313          * We're called over smp_call_function_single() and therefore
314          * are on the correct cpu.
315          */
316         int cpu = smp_processor_id();
317         int node = cpu_to_node(cpu);
318         struct pci_dev *dev = node_to_k8_nb_misc(node);
319         unsigned int sc0, sc1, sc2, sc3;
320         u32 val = 0;
321
322         pci_read_config_dword(dev, 0x1C4, &val);
323
324         /* calculate subcache sizes */
325         l3->subcaches[0] = sc0 = !(val & BIT(0));
326         l3->subcaches[1] = sc1 = !(val & BIT(4));
327         l3->subcaches[2] = sc2 = !(val & BIT(8))  + !(val & BIT(9));
328         l3->subcaches[3] = sc3 = !(val & BIT(12)) + !(val & BIT(13));
329
330         l3->indices = (max(max(max(sc0, sc1), sc2), sc3) << 10) - 1;
331
332         l3->dev = dev;
333 }
334
335 static void __cpuinit
336 amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf)
337 {
338         if (boot_cpu_data.x86 != 0x10)
339                 return;
340
341         if (index < 3)
342                 return;
343
344         /* see errata #382 and #388 */
345         if (boot_cpu_data.x86_model < 0x8)
346                 return;
347
348         if ((boot_cpu_data.x86_model == 0x8 ||
349              boot_cpu_data.x86_model == 0x9)
350                 &&
351              boot_cpu_data.x86_mask < 0x1)
352                         return;
353
354         /* not in virtualized environments */
355         if (num_k8_northbridges == 0)
356                 return;
357
358         this_leaf->l3 = kzalloc(sizeof(struct amd_l3_cache), GFP_ATOMIC);
359         if (!this_leaf->l3) {
360                 printk(KERN_WARNING "Error allocating L3 struct\n");
361                 return;
362         }
363
364         this_leaf->l3->can_disable = true;
365         amd_calc_l3_indices(this_leaf->l3);
366 }
367
368 static ssize_t show_cache_disable(struct _cpuid4_info *this_leaf, char *buf,
369                                   unsigned int index)
370 {
371         struct pci_dev *dev = this_leaf->l3->dev;
372         unsigned int reg = 0;
373
374         if (!this_leaf->l3 || !this_leaf->l3->can_disable)
375                 return -EINVAL;
376
377         if (!dev)
378                 return -EINVAL;
379
380         pci_read_config_dword(dev, 0x1BC + index * 4, &reg);
381         return sprintf(buf, "0x%08x\n", reg);
382 }
383
384 #define SHOW_CACHE_DISABLE(index)                                       \
385 static ssize_t                                                          \
386 show_cache_disable_##index(struct _cpuid4_info *this_leaf, char *buf)   \
387 {                                                                       \
388         return show_cache_disable(this_leaf, buf, index);               \
389 }
390 SHOW_CACHE_DISABLE(0)
391 SHOW_CACHE_DISABLE(1)
392
393 static ssize_t store_cache_disable(struct _cpuid4_info *this_leaf,
394         const char *buf, size_t count, unsigned int index)
395 {
396         struct pci_dev *dev = this_leaf->l3->dev;
397         int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map));
398         unsigned long val = 0;
399
400 #define SUBCACHE_MASK   (3UL << 20)
401 #define SUBCACHE_INDEX  0xfff
402
403         if (!this_leaf->l3 || !this_leaf->l3->can_disable)
404                 return -EINVAL;
405
406         if (!capable(CAP_SYS_ADMIN))
407                 return -EPERM;
408
409         if (!dev)
410                 return -EINVAL;
411
412         if (strict_strtoul(buf, 10, &val) < 0)
413                 return -EINVAL;
414
415         /* do not allow writes outside of allowed bits */
416         if ((val & ~(SUBCACHE_MASK | SUBCACHE_INDEX)) ||
417             ((val & SUBCACHE_INDEX) > this_leaf->l3->indices))
418                 return -EINVAL;
419
420         val |= BIT(30);
421         pci_write_config_dword(dev, 0x1BC + index * 4, val);
422         /*
423          * We need to WBINVD on a core on the node containing the L3 cache which
424          * indices we disable therefore a simple wbinvd() is not sufficient.
425          */
426         wbinvd_on_cpu(cpu);
427         pci_write_config_dword(dev, 0x1BC + index * 4, val | BIT(31));
428         return count;
429 }
430
431 #define STORE_CACHE_DISABLE(index)                                      \
432 static ssize_t                                                          \
433 store_cache_disable_##index(struct _cpuid4_info *this_leaf,             \
434                             const char *buf, size_t count)              \
435 {                                                                       \
436         return store_cache_disable(this_leaf, buf, count, index);       \
437 }
438 STORE_CACHE_DISABLE(0)
439 STORE_CACHE_DISABLE(1)
440
441 static struct _cache_attr cache_disable_0 = __ATTR(cache_disable_0, 0644,
442                 show_cache_disable_0, store_cache_disable_0);
443 static struct _cache_attr cache_disable_1 = __ATTR(cache_disable_1, 0644,
444                 show_cache_disable_1, store_cache_disable_1);
445
446 #else   /* CONFIG_CPU_SUP_AMD */
447 static void __cpuinit
448 amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf)
449 {
450 };
451 #endif /* CONFIG_CPU_SUP_AMD */
452
453 static int
454 __cpuinit cpuid4_cache_lookup_regs(int index,
455                                    struct _cpuid4_info_regs *this_leaf)
456 {
457         union _cpuid4_leaf_eax  eax;
458         union _cpuid4_leaf_ebx  ebx;
459         union _cpuid4_leaf_ecx  ecx;
460         unsigned                edx;
461
462         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
463                 amd_cpuid4(index, &eax, &ebx, &ecx);
464                 amd_check_l3_disable(index, this_leaf);
465         } else {
466                 cpuid_count(4, index, &eax.full, &ebx.full, &ecx.full, &edx);
467         }
468
469         if (eax.split.type == CACHE_TYPE_NULL)
470                 return -EIO; /* better error ? */
471
472         this_leaf->eax = eax;
473         this_leaf->ebx = ebx;
474         this_leaf->ecx = ecx;
475         this_leaf->size = (ecx.split.number_of_sets          + 1) *
476                           (ebx.split.coherency_line_size     + 1) *
477                           (ebx.split.physical_line_partition + 1) *
478                           (ebx.split.ways_of_associativity   + 1);
479         return 0;
480 }
481
482 static int __cpuinit find_num_cache_leaves(void)
483 {
484         unsigned int            eax, ebx, ecx, edx;
485         union _cpuid4_leaf_eax  cache_eax;
486         int                     i = -1;
487
488         do {
489                 ++i;
490                 /* Do cpuid(4) loop to find out num_cache_leaves */
491                 cpuid_count(4, i, &eax, &ebx, &ecx, &edx);
492                 cache_eax.full = eax;
493         } while (cache_eax.split.type != CACHE_TYPE_NULL);
494         return i;
495 }
496
497 unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
498 {
499         /* Cache sizes */
500         unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0;
501         unsigned int new_l1d = 0, new_l1i = 0; /* Cache sizes from cpuid(4) */
502         unsigned int new_l2 = 0, new_l3 = 0, i; /* Cache sizes from cpuid(4) */
503         unsigned int l2_id = 0, l3_id = 0, num_threads_sharing, index_msb;
504 #ifdef CONFIG_X86_HT
505         unsigned int cpu = c->cpu_index;
506 #endif
507
508         if (c->cpuid_level > 3) {
509                 static int is_initialized;
510
511                 if (is_initialized == 0) {
512                         /* Init num_cache_leaves from boot CPU */
513                         num_cache_leaves = find_num_cache_leaves();
514                         is_initialized++;
515                 }
516
517                 /*
518                  * Whenever possible use cpuid(4), deterministic cache
519                  * parameters cpuid leaf to find the cache details
520                  */
521                 for (i = 0; i < num_cache_leaves; i++) {
522                         struct _cpuid4_info_regs this_leaf;
523                         int retval;
524
525                         retval = cpuid4_cache_lookup_regs(i, &this_leaf);
526                         if (retval >= 0) {
527                                 switch (this_leaf.eax.split.level) {
528                                 case 1:
529                                         if (this_leaf.eax.split.type ==
530                                                         CACHE_TYPE_DATA)
531                                                 new_l1d = this_leaf.size/1024;
532                                         else if (this_leaf.eax.split.type ==
533                                                         CACHE_TYPE_INST)
534                                                 new_l1i = this_leaf.size/1024;
535                                         break;
536                                 case 2:
537                                         new_l2 = this_leaf.size/1024;
538                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
539                                         index_msb = get_count_order(num_threads_sharing);
540                                         l2_id = c->apicid >> index_msb;
541                                         break;
542                                 case 3:
543                                         new_l3 = this_leaf.size/1024;
544                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
545                                         index_msb = get_count_order(
546                                                         num_threads_sharing);
547                                         l3_id = c->apicid >> index_msb;
548                                         break;
549                                 default:
550                                         break;
551                                 }
552                         }
553                 }
554         }
555         /*
556          * Don't use cpuid2 if cpuid4 is supported. For P4, we use cpuid2 for
557          * trace cache
558          */
559         if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
560                 /* supports eax=2  call */
561                 int j, n;
562                 unsigned int regs[4];
563                 unsigned char *dp = (unsigned char *)regs;
564                 int only_trace = 0;
565
566                 if (num_cache_leaves != 0 && c->x86 == 15)
567                         only_trace = 1;
568
569                 /* Number of times to iterate */
570                 n = cpuid_eax(2) & 0xFF;
571
572                 for (i = 0 ; i < n ; i++) {
573                         cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
574
575                         /* If bit 31 is set, this is an unknown format */
576                         for (j = 0 ; j < 3 ; j++)
577                                 if (regs[j] & (1 << 31))
578                                         regs[j] = 0;
579
580                         /* Byte 0 is level count, not a descriptor */
581                         for (j = 1 ; j < 16 ; j++) {
582                                 unsigned char des = dp[j];
583                                 unsigned char k = 0;
584
585                                 /* look up this descriptor in the table */
586                                 while (cache_table[k].descriptor != 0) {
587                                         if (cache_table[k].descriptor == des) {
588                                                 if (only_trace && cache_table[k].cache_type != LVL_TRACE)
589                                                         break;
590                                                 switch (cache_table[k].cache_type) {
591                                                 case LVL_1_INST:
592                                                         l1i += cache_table[k].size;
593                                                         break;
594                                                 case LVL_1_DATA:
595                                                         l1d += cache_table[k].size;
596                                                         break;
597                                                 case LVL_2:
598                                                         l2 += cache_table[k].size;
599                                                         break;
600                                                 case LVL_3:
601                                                         l3 += cache_table[k].size;
602                                                         break;
603                                                 case LVL_TRACE:
604                                                         trace += cache_table[k].size;
605                                                         break;
606                                                 }
607
608                                                 break;
609                                         }
610
611                                         k++;
612                                 }
613                         }
614                 }
615         }
616
617         if (new_l1d)
618                 l1d = new_l1d;
619
620         if (new_l1i)
621                 l1i = new_l1i;
622
623         if (new_l2) {
624                 l2 = new_l2;
625 #ifdef CONFIG_X86_HT
626                 per_cpu(cpu_llc_id, cpu) = l2_id;
627 #endif
628         }
629
630         if (new_l3) {
631                 l3 = new_l3;
632 #ifdef CONFIG_X86_HT
633                 per_cpu(cpu_llc_id, cpu) = l3_id;
634 #endif
635         }
636
637         c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
638
639         return l2;
640 }
641
642 #ifdef CONFIG_SYSFS
643
644 /* pointer to _cpuid4_info array (for each cache leaf) */
645 static DEFINE_PER_CPU(struct _cpuid4_info *, ici_cpuid4_info);
646 #define CPUID4_INFO_IDX(x, y)   (&((per_cpu(ici_cpuid4_info, x))[y]))
647
648 #ifdef CONFIG_SMP
649 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
650 {
651         struct _cpuid4_info     *this_leaf, *sibling_leaf;
652         unsigned long num_threads_sharing;
653         int index_msb, i, sibling;
654         struct cpuinfo_x86 *c = &cpu_data(cpu);
655
656         if ((index == 3) && (c->x86_vendor == X86_VENDOR_AMD)) {
657                 for_each_cpu(i, c->llc_shared_map) {
658                         if (!per_cpu(ici_cpuid4_info, i))
659                                 continue;
660                         this_leaf = CPUID4_INFO_IDX(i, index);
661                         for_each_cpu(sibling, c->llc_shared_map) {
662                                 if (!cpu_online(sibling))
663                                         continue;
664                                 set_bit(sibling, this_leaf->shared_cpu_map);
665                         }
666                 }
667                 return;
668         }
669         this_leaf = CPUID4_INFO_IDX(cpu, index);
670         num_threads_sharing = 1 + this_leaf->eax.split.num_threads_sharing;
671
672         if (num_threads_sharing == 1)
673                 cpumask_set_cpu(cpu, to_cpumask(this_leaf->shared_cpu_map));
674         else {
675                 index_msb = get_count_order(num_threads_sharing);
676
677                 for_each_online_cpu(i) {
678                         if (cpu_data(i).apicid >> index_msb ==
679                             c->apicid >> index_msb) {
680                                 cpumask_set_cpu(i,
681                                         to_cpumask(this_leaf->shared_cpu_map));
682                                 if (i != cpu && per_cpu(ici_cpuid4_info, i))  {
683                                         sibling_leaf =
684                                                 CPUID4_INFO_IDX(i, index);
685                                         cpumask_set_cpu(cpu, to_cpumask(
686                                                 sibling_leaf->shared_cpu_map));
687                                 }
688                         }
689                 }
690         }
691 }
692 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
693 {
694         struct _cpuid4_info     *this_leaf, *sibling_leaf;
695         int sibling;
696
697         this_leaf = CPUID4_INFO_IDX(cpu, index);
698         for_each_cpu(sibling, to_cpumask(this_leaf->shared_cpu_map)) {
699                 sibling_leaf = CPUID4_INFO_IDX(sibling, index);
700                 cpumask_clear_cpu(cpu,
701                                   to_cpumask(sibling_leaf->shared_cpu_map));
702         }
703 }
704 #else
705 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
706 {
707 }
708
709 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
710 {
711 }
712 #endif
713
714 static void __cpuinit free_cache_attributes(unsigned int cpu)
715 {
716         int i;
717
718         for (i = 0; i < num_cache_leaves; i++)
719                 cache_remove_shared_cpu_map(cpu, i);
720
721         kfree(per_cpu(ici_cpuid4_info, cpu)->l3);
722         kfree(per_cpu(ici_cpuid4_info, cpu));
723         per_cpu(ici_cpuid4_info, cpu) = NULL;
724 }
725
726 static int
727 __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_leaf)
728 {
729         struct _cpuid4_info_regs *leaf_regs =
730                 (struct _cpuid4_info_regs *)this_leaf;
731
732         return cpuid4_cache_lookup_regs(index, leaf_regs);
733 }
734
735 static void __cpuinit get_cpu_leaves(void *_retval)
736 {
737         int j, *retval = _retval, cpu = smp_processor_id();
738
739         /* Do cpuid and store the results */
740         for (j = 0; j < num_cache_leaves; j++) {
741                 struct _cpuid4_info *this_leaf;
742                 this_leaf = CPUID4_INFO_IDX(cpu, j);
743                 *retval = cpuid4_cache_lookup(j, this_leaf);
744                 if (unlikely(*retval < 0)) {
745                         int i;
746
747                         for (i = 0; i < j; i++)
748                                 cache_remove_shared_cpu_map(cpu, i);
749                         break;
750                 }
751                 cache_shared_cpu_map_setup(cpu, j);
752         }
753 }
754
755 static int __cpuinit detect_cache_attributes(unsigned int cpu)
756 {
757         int                     retval;
758
759         if (num_cache_leaves == 0)
760                 return -ENOENT;
761
762         per_cpu(ici_cpuid4_info, cpu) = kzalloc(
763             sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
764         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
765                 return -ENOMEM;
766
767         smp_call_function_single(cpu, get_cpu_leaves, &retval, true);
768         if (retval) {
769                 kfree(per_cpu(ici_cpuid4_info, cpu));
770                 per_cpu(ici_cpuid4_info, cpu) = NULL;
771         }
772
773         return retval;
774 }
775
776 #include <linux/kobject.h>
777 #include <linux/sysfs.h>
778
779 extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
780
781 /* pointer to kobject for cpuX/cache */
782 static DEFINE_PER_CPU(struct kobject *, ici_cache_kobject);
783
784 struct _index_kobject {
785         struct kobject kobj;
786         unsigned int cpu;
787         unsigned short index;
788 };
789
790 /* pointer to array of kobjects for cpuX/cache/indexY */
791 static DEFINE_PER_CPU(struct _index_kobject *, ici_index_kobject);
792 #define INDEX_KOBJECT_PTR(x, y)         (&((per_cpu(ici_index_kobject, x))[y]))
793
794 #define show_one_plus(file_name, object, val)                           \
795 static ssize_t show_##file_name                                         \
796                         (struct _cpuid4_info *this_leaf, char *buf)     \
797 {                                                                       \
798         return sprintf(buf, "%lu\n", (unsigned long)this_leaf->object + val); \
799 }
800
801 show_one_plus(level, eax.split.level, 0);
802 show_one_plus(coherency_line_size, ebx.split.coherency_line_size, 1);
803 show_one_plus(physical_line_partition, ebx.split.physical_line_partition, 1);
804 show_one_plus(ways_of_associativity, ebx.split.ways_of_associativity, 1);
805 show_one_plus(number_of_sets, ecx.split.number_of_sets, 1);
806
807 static ssize_t show_size(struct _cpuid4_info *this_leaf, char *buf)
808 {
809         return sprintf(buf, "%luK\n", this_leaf->size / 1024);
810 }
811
812 static ssize_t show_shared_cpu_map_func(struct _cpuid4_info *this_leaf,
813                                         int type, char *buf)
814 {
815         ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
816         int n = 0;
817
818         if (len > 1) {
819                 const struct cpumask *mask;
820
821                 mask = to_cpumask(this_leaf->shared_cpu_map);
822                 n = type ?
823                         cpulist_scnprintf(buf, len-2, mask) :
824                         cpumask_scnprintf(buf, len-2, mask);
825                 buf[n++] = '\n';
826                 buf[n] = '\0';
827         }
828         return n;
829 }
830
831 static inline ssize_t show_shared_cpu_map(struct _cpuid4_info *leaf, char *buf)
832 {
833         return show_shared_cpu_map_func(leaf, 0, buf);
834 }
835
836 static inline ssize_t show_shared_cpu_list(struct _cpuid4_info *leaf, char *buf)
837 {
838         return show_shared_cpu_map_func(leaf, 1, buf);
839 }
840
841 static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf)
842 {
843         switch (this_leaf->eax.split.type) {
844         case CACHE_TYPE_DATA:
845                 return sprintf(buf, "Data\n");
846         case CACHE_TYPE_INST:
847                 return sprintf(buf, "Instruction\n");
848         case CACHE_TYPE_UNIFIED:
849                 return sprintf(buf, "Unified\n");
850         default:
851                 return sprintf(buf, "Unknown\n");
852         }
853 }
854
855 #define to_object(k)    container_of(k, struct _index_kobject, kobj)
856 #define to_attr(a)      container_of(a, struct _cache_attr, attr)
857
858 #define define_one_ro(_name) \
859 static struct _cache_attr _name = \
860         __ATTR(_name, 0444, show_##_name, NULL)
861
862 define_one_ro(level);
863 define_one_ro(type);
864 define_one_ro(coherency_line_size);
865 define_one_ro(physical_line_partition);
866 define_one_ro(ways_of_associativity);
867 define_one_ro(number_of_sets);
868 define_one_ro(size);
869 define_one_ro(shared_cpu_map);
870 define_one_ro(shared_cpu_list);
871
872 #define DEFAULT_SYSFS_CACHE_ATTRS       \
873         &type.attr,                     \
874         &level.attr,                    \
875         &coherency_line_size.attr,      \
876         &physical_line_partition.attr,  \
877         &ways_of_associativity.attr,    \
878         &number_of_sets.attr,           \
879         &size.attr,                     \
880         &shared_cpu_map.attr,           \
881         &shared_cpu_list.attr
882
883 static struct attribute *default_attrs[] = {
884         DEFAULT_SYSFS_CACHE_ATTRS,
885         NULL
886 };
887
888 static struct attribute *default_l3_attrs[] = {
889         DEFAULT_SYSFS_CACHE_ATTRS,
890 #ifdef CONFIG_CPU_SUP_AMD
891         &cache_disable_0.attr,
892         &cache_disable_1.attr,
893 #endif
894         NULL
895 };
896
897 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
898 {
899         struct _cache_attr *fattr = to_attr(attr);
900         struct _index_kobject *this_leaf = to_object(kobj);
901         ssize_t ret;
902
903         ret = fattr->show ?
904                 fattr->show(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
905                         buf) :
906                 0;
907         return ret;
908 }
909
910 static ssize_t store(struct kobject *kobj, struct attribute *attr,
911                      const char *buf, size_t count)
912 {
913         struct _cache_attr *fattr = to_attr(attr);
914         struct _index_kobject *this_leaf = to_object(kobj);
915         ssize_t ret;
916
917         ret = fattr->store ?
918                 fattr->store(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
919                         buf, count) :
920                 0;
921         return ret;
922 }
923
924 static const struct sysfs_ops sysfs_ops = {
925         .show   = show,
926         .store  = store,
927 };
928
929 static struct kobj_type ktype_cache = {
930         .sysfs_ops      = &sysfs_ops,
931         .default_attrs  = default_attrs,
932 };
933
934 static struct kobj_type ktype_percpu_entry = {
935         .sysfs_ops      = &sysfs_ops,
936 };
937
938 static void __cpuinit cpuid4_cache_sysfs_exit(unsigned int cpu)
939 {
940         kfree(per_cpu(ici_cache_kobject, cpu));
941         kfree(per_cpu(ici_index_kobject, cpu));
942         per_cpu(ici_cache_kobject, cpu) = NULL;
943         per_cpu(ici_index_kobject, cpu) = NULL;
944         free_cache_attributes(cpu);
945 }
946
947 static int __cpuinit cpuid4_cache_sysfs_init(unsigned int cpu)
948 {
949         int err;
950
951         if (num_cache_leaves == 0)
952                 return -ENOENT;
953
954         err = detect_cache_attributes(cpu);
955         if (err)
956                 return err;
957
958         /* Allocate all required memory */
959         per_cpu(ici_cache_kobject, cpu) =
960                 kzalloc(sizeof(struct kobject), GFP_KERNEL);
961         if (unlikely(per_cpu(ici_cache_kobject, cpu) == NULL))
962                 goto err_out;
963
964         per_cpu(ici_index_kobject, cpu) = kzalloc(
965             sizeof(struct _index_kobject) * num_cache_leaves, GFP_KERNEL);
966         if (unlikely(per_cpu(ici_index_kobject, cpu) == NULL))
967                 goto err_out;
968
969         return 0;
970
971 err_out:
972         cpuid4_cache_sysfs_exit(cpu);
973         return -ENOMEM;
974 }
975
976 static DECLARE_BITMAP(cache_dev_map, NR_CPUS);
977
978 /* Add/Remove cache interface for CPU device */
979 static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
980 {
981         unsigned int cpu = sys_dev->id;
982         unsigned long i, j;
983         struct _index_kobject *this_object;
984         struct _cpuid4_info   *this_leaf;
985         int retval;
986
987         retval = cpuid4_cache_sysfs_init(cpu);
988         if (unlikely(retval < 0))
989                 return retval;
990
991         retval = kobject_init_and_add(per_cpu(ici_cache_kobject, cpu),
992                                       &ktype_percpu_entry,
993                                       &sys_dev->kobj, "%s", "cache");
994         if (retval < 0) {
995                 cpuid4_cache_sysfs_exit(cpu);
996                 return retval;
997         }
998
999         for (i = 0; i < num_cache_leaves; i++) {
1000                 this_object = INDEX_KOBJECT_PTR(cpu, i);
1001                 this_object->cpu = cpu;
1002                 this_object->index = i;
1003
1004                 this_leaf = CPUID4_INFO_IDX(cpu, i);
1005
1006                 if (this_leaf->l3 && this_leaf->l3->can_disable)
1007                         ktype_cache.default_attrs = default_l3_attrs;
1008                 else
1009                         ktype_cache.default_attrs = default_attrs;
1010
1011                 retval = kobject_init_and_add(&(this_object->kobj),
1012                                               &ktype_cache,
1013                                               per_cpu(ici_cache_kobject, cpu),
1014                                               "index%1lu", i);
1015                 if (unlikely(retval)) {
1016                         for (j = 0; j < i; j++)
1017                                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, j)->kobj));
1018                         kobject_put(per_cpu(ici_cache_kobject, cpu));
1019                         cpuid4_cache_sysfs_exit(cpu);
1020                         return retval;
1021                 }
1022                 kobject_uevent(&(this_object->kobj), KOBJ_ADD);
1023         }
1024         cpumask_set_cpu(cpu, to_cpumask(cache_dev_map));
1025
1026         kobject_uevent(per_cpu(ici_cache_kobject, cpu), KOBJ_ADD);
1027         return 0;
1028 }
1029
1030 static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
1031 {
1032         unsigned int cpu = sys_dev->id;
1033         unsigned long i;
1034
1035         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
1036                 return;
1037         if (!cpumask_test_cpu(cpu, to_cpumask(cache_dev_map)))
1038                 return;
1039         cpumask_clear_cpu(cpu, to_cpumask(cache_dev_map));
1040
1041         for (i = 0; i < num_cache_leaves; i++)
1042                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, i)->kobj));
1043         kobject_put(per_cpu(ici_cache_kobject, cpu));
1044         cpuid4_cache_sysfs_exit(cpu);
1045 }
1046
1047 static int __cpuinit cacheinfo_cpu_callback(struct notifier_block *nfb,
1048                                         unsigned long action, void *hcpu)
1049 {
1050         unsigned int cpu = (unsigned long)hcpu;
1051         struct sys_device *sys_dev;
1052
1053         sys_dev = get_cpu_sysdev(cpu);
1054         switch (action) {
1055         case CPU_ONLINE:
1056         case CPU_ONLINE_FROZEN:
1057                 cache_add_dev(sys_dev);
1058                 break;
1059         case CPU_DEAD:
1060         case CPU_DEAD_FROZEN:
1061                 cache_remove_dev(sys_dev);
1062                 break;
1063         }
1064         return NOTIFY_OK;
1065 }
1066
1067 static struct notifier_block __cpuinitdata cacheinfo_cpu_notifier = {
1068         .notifier_call = cacheinfo_cpu_callback,
1069 };
1070
1071 static int __cpuinit cache_sysfs_init(void)
1072 {
1073         int i;
1074
1075         if (num_cache_leaves == 0)
1076                 return 0;
1077
1078         for_each_online_cpu(i) {
1079                 int err;
1080                 struct sys_device *sys_dev = get_cpu_sysdev(i);
1081
1082                 err = cache_add_dev(sys_dev);
1083                 if (err)
1084                         return err;
1085         }
1086         register_hotcpu_notifier(&cacheinfo_cpu_notifier);
1087         return 0;
1088 }
1089
1090 device_initcall(cache_sysfs_init);
1091
1092 #endif