Merge branch 'x86/core' into perfcounters/core
[linux-3.10.git] / arch / x86 / kernel / cpu / common.c
1 #include <linux/init.h>
2 #include <linux/kernel.h>
3 #include <linux/sched.h>
4 #include <linux/string.h>
5 #include <linux/bootmem.h>
6 #include <linux/bitops.h>
7 #include <linux/module.h>
8 #include <linux/kgdb.h>
9 #include <linux/topology.h>
10 #include <linux/delay.h>
11 #include <linux/smp.h>
12 #include <linux/percpu.h>
13 #include <asm/i387.h>
14 #include <asm/msr.h>
15 #include <asm/io.h>
16 #include <asm/linkage.h>
17 #include <asm/mmu_context.h>
18 #include <asm/mtrr.h>
19 #include <asm/mce.h>
20 #include <asm/perf_counter.h>
21 #include <asm/pat.h>
22 #include <asm/asm.h>
23 #include <asm/numa.h>
24 #include <asm/smp.h>
25 #include <asm/cpu.h>
26 #include <asm/cpumask.h>
27 #ifdef CONFIG_X86_LOCAL_APIC
28 #include <asm/mpspec.h>
29 #include <asm/apic.h>
30 #include <asm/genapic.h>
31 #include <asm/genapic.h>
32 #include <asm/uv/uv.h>
33 #endif
34
35 #include <asm/pgtable.h>
36 #include <asm/processor.h>
37 #include <asm/desc.h>
38 #include <asm/atomic.h>
39 #include <asm/proto.h>
40 #include <asm/sections.h>
41 #include <asm/setup.h>
42 #include <asm/hypervisor.h>
43 #include <asm/stackprotector.h>
44
45 #include "cpu.h"
46
47 #ifdef CONFIG_X86_64
48
49 /* all of these masks are initialized in setup_cpu_local_masks() */
50 cpumask_var_t cpu_callin_mask;
51 cpumask_var_t cpu_callout_mask;
52 cpumask_var_t cpu_initialized_mask;
53
54 /* representing cpus for which sibling maps can be computed */
55 cpumask_var_t cpu_sibling_setup_mask;
56
57 /* correctly size the local cpu masks */
58 void __init setup_cpu_local_masks(void)
59 {
60         alloc_bootmem_cpumask_var(&cpu_initialized_mask);
61         alloc_bootmem_cpumask_var(&cpu_callin_mask);
62         alloc_bootmem_cpumask_var(&cpu_callout_mask);
63         alloc_bootmem_cpumask_var(&cpu_sibling_setup_mask);
64 }
65
66 #else /* CONFIG_X86_32 */
67
68 cpumask_t cpu_callin_map;
69 cpumask_t cpu_callout_map;
70 cpumask_t cpu_initialized;
71 cpumask_t cpu_sibling_setup_map;
72
73 #endif /* CONFIG_X86_32 */
74
75
76 static struct cpu_dev *this_cpu __cpuinitdata;
77
78 DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
79 #ifdef CONFIG_X86_64
80         /*
81          * We need valid kernel segments for data and code in long mode too
82          * IRET will check the segment types  kkeil 2000/10/28
83          * Also sysret mandates a special GDT layout
84          *
85          * The TLS descriptors are currently at a different place compared to i386.
86          * Hopefully nobody expects them at a fixed place (Wine?)
87          */
88         [GDT_ENTRY_KERNEL32_CS] = { { { 0x0000ffff, 0x00cf9b00 } } },
89         [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00af9b00 } } },
90         [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9300 } } },
91         [GDT_ENTRY_DEFAULT_USER32_CS] = { { { 0x0000ffff, 0x00cffb00 } } },
92         [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff300 } } },
93         [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00affb00 } } },
94 #else
95         [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } },
96         [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } },
97         [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } },
98         [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } },
99         /*
100          * Segments used for calling PnP BIOS have byte granularity.
101          * They code segments and data segments have fixed 64k limits,
102          * the transfer segment sizes are set at run time.
103          */
104         /* 32-bit code */
105         [GDT_ENTRY_PNPBIOS_CS32] = { { { 0x0000ffff, 0x00409a00 } } },
106         /* 16-bit code */
107         [GDT_ENTRY_PNPBIOS_CS16] = { { { 0x0000ffff, 0x00009a00 } } },
108         /* 16-bit data */
109         [GDT_ENTRY_PNPBIOS_DS] = { { { 0x0000ffff, 0x00009200 } } },
110         /* 16-bit data */
111         [GDT_ENTRY_PNPBIOS_TS1] = { { { 0x00000000, 0x00009200 } } },
112         /* 16-bit data */
113         [GDT_ENTRY_PNPBIOS_TS2] = { { { 0x00000000, 0x00009200 } } },
114         /*
115          * The APM segments have byte granularity and their bases
116          * are set at run time.  All have 64k limits.
117          */
118         /* 32-bit code */
119         [GDT_ENTRY_APMBIOS_BASE] = { { { 0x0000ffff, 0x00409a00 } } },
120         /* 16-bit code */
121         [GDT_ENTRY_APMBIOS_BASE+1] = { { { 0x0000ffff, 0x00009a00 } } },
122         /* data */
123         [GDT_ENTRY_APMBIOS_BASE+2] = { { { 0x0000ffff, 0x00409200 } } },
124
125         [GDT_ENTRY_ESPFIX_SS] = { { { 0x00000000, 0x00c09200 } } },
126         [GDT_ENTRY_PERCPU] = { { { 0x0000ffff, 0x00cf9200 } } },
127         GDT_STACK_CANARY_INIT
128 #endif
129 } };
130 EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
131
132 #ifdef CONFIG_X86_32
133 static int cachesize_override __cpuinitdata = -1;
134 static int disable_x86_serial_nr __cpuinitdata = 1;
135
136 static int __init cachesize_setup(char *str)
137 {
138         get_option(&str, &cachesize_override);
139         return 1;
140 }
141 __setup("cachesize=", cachesize_setup);
142
143 static int __init x86_fxsr_setup(char *s)
144 {
145         setup_clear_cpu_cap(X86_FEATURE_FXSR);
146         setup_clear_cpu_cap(X86_FEATURE_XMM);
147         return 1;
148 }
149 __setup("nofxsr", x86_fxsr_setup);
150
151 static int __init x86_sep_setup(char *s)
152 {
153         setup_clear_cpu_cap(X86_FEATURE_SEP);
154         return 1;
155 }
156 __setup("nosep", x86_sep_setup);
157
158 /* Standard macro to see if a specific flag is changeable */
159 static inline int flag_is_changeable_p(u32 flag)
160 {
161         u32 f1, f2;
162
163         /*
164          * Cyrix and IDT cpus allow disabling of CPUID
165          * so the code below may return different results
166          * when it is executed before and after enabling
167          * the CPUID. Add "volatile" to not allow gcc to
168          * optimize the subsequent calls to this function.
169          */
170         asm volatile ("pushfl\n\t"
171                       "pushfl\n\t"
172                       "popl %0\n\t"
173                       "movl %0,%1\n\t"
174                       "xorl %2,%0\n\t"
175                       "pushl %0\n\t"
176                       "popfl\n\t"
177                       "pushfl\n\t"
178                       "popl %0\n\t"
179                       "popfl\n\t"
180                       : "=&r" (f1), "=&r" (f2)
181                       : "ir" (flag));
182
183         return ((f1^f2) & flag) != 0;
184 }
185
186 /* Probe for the CPUID instruction */
187 static int __cpuinit have_cpuid_p(void)
188 {
189         return flag_is_changeable_p(X86_EFLAGS_ID);
190 }
191
192 static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
193 {
194         if (cpu_has(c, X86_FEATURE_PN) && disable_x86_serial_nr) {
195                 /* Disable processor serial number */
196                 unsigned long lo, hi;
197                 rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
198                 lo |= 0x200000;
199                 wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
200                 printk(KERN_NOTICE "CPU serial number disabled.\n");
201                 clear_cpu_cap(c, X86_FEATURE_PN);
202
203                 /* Disabling the serial number may affect the cpuid level */
204                 c->cpuid_level = cpuid_eax(0);
205         }
206 }
207
208 static int __init x86_serial_nr_setup(char *s)
209 {
210         disable_x86_serial_nr = 0;
211         return 1;
212 }
213 __setup("serialnumber", x86_serial_nr_setup);
214 #else
215 static inline int flag_is_changeable_p(u32 flag)
216 {
217         return 1;
218 }
219 /* Probe for the CPUID instruction */
220 static inline int have_cpuid_p(void)
221 {
222         return 1;
223 }
224 static inline void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
225 {
226 }
227 #endif
228
229 /*
230  * Some CPU features depend on higher CPUID levels, which may not always
231  * be available due to CPUID level capping or broken virtualization
232  * software.  Add those features to this table to auto-disable them.
233  */
234 struct cpuid_dependent_feature {
235         u32 feature;
236         u32 level;
237 };
238 static const struct cpuid_dependent_feature __cpuinitconst
239 cpuid_dependent_features[] = {
240         { X86_FEATURE_MWAIT,            0x00000005 },
241         { X86_FEATURE_DCA,              0x00000009 },
242         { X86_FEATURE_XSAVE,            0x0000000d },
243         { 0, 0 }
244 };
245
246 static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
247 {
248         const struct cpuid_dependent_feature *df;
249         for (df = cpuid_dependent_features; df->feature; df++) {
250                 /*
251                  * Note: cpuid_level is set to -1 if unavailable, but
252                  * extended_extended_level is set to 0 if unavailable
253                  * and the legitimate extended levels are all negative
254                  * when signed; hence the weird messing around with
255                  * signs here...
256                  */
257                 if (cpu_has(c, df->feature) &&
258                     ((s32)df->feature < 0 ?
259                      (u32)df->feature > (u32)c->extended_cpuid_level :
260                      (s32)df->feature > (s32)c->cpuid_level)) {
261                         clear_cpu_cap(c, df->feature);
262                         if (warn)
263                                 printk(KERN_WARNING
264                                        "CPU: CPU feature %s disabled "
265                                        "due to lack of CPUID level 0x%x\n",
266                                        x86_cap_flags[df->feature],
267                                        df->level);
268                 }
269         }
270 }       
271
272 /*
273  * Naming convention should be: <Name> [(<Codename>)]
274  * This table only is used unless init_<vendor>() below doesn't set it;
275  * in particular, if CPUID levels 0x80000002..4 are supported, this isn't used
276  *
277  */
278
279 /* Look up CPU names by table lookup. */
280 static char __cpuinit *table_lookup_model(struct cpuinfo_x86 *c)
281 {
282         struct cpu_model_info *info;
283
284         if (c->x86_model >= 16)
285                 return NULL;    /* Range check */
286
287         if (!this_cpu)
288                 return NULL;
289
290         info = this_cpu->c_models;
291
292         while (info && info->family) {
293                 if (info->family == c->x86)
294                         return info->model_names[c->x86_model];
295                 info++;
296         }
297         return NULL;            /* Not found */
298 }
299
300 __u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;
301
302 void load_percpu_segment(int cpu)
303 {
304 #ifdef CONFIG_X86_32
305         loadsegment(fs, __KERNEL_PERCPU);
306 #else
307         loadsegment(gs, 0);
308         wrmsrl(MSR_GS_BASE, (unsigned long)per_cpu(irq_stack_union.gs_base, cpu));
309 #endif
310         load_stack_canary_segment();
311 }
312
313 /* Current gdt points %fs at the "master" per-cpu area: after this,
314  * it's on the real one. */
315 void switch_to_new_gdt(int cpu)
316 {
317         struct desc_ptr gdt_descr;
318
319         gdt_descr.address = (long)get_cpu_gdt_table(cpu);
320         gdt_descr.size = GDT_SIZE - 1;
321         load_gdt(&gdt_descr);
322         /* Reload the per-cpu base */
323
324         load_percpu_segment(cpu);
325 }
326
327 static struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
328
329 static void __cpuinit default_init(struct cpuinfo_x86 *c)
330 {
331 #ifdef CONFIG_X86_64
332         display_cacheinfo(c);
333 #else
334         /* Not much we can do here... */
335         /* Check if at least it has cpuid */
336         if (c->cpuid_level == -1) {
337                 /* No cpuid. It must be an ancient CPU */
338                 if (c->x86 == 4)
339                         strcpy(c->x86_model_id, "486");
340                 else if (c->x86 == 3)
341                         strcpy(c->x86_model_id, "386");
342         }
343 #endif
344 }
345
346 static struct cpu_dev __cpuinitdata default_cpu = {
347         .c_init = default_init,
348         .c_vendor = "Unknown",
349         .c_x86_vendor = X86_VENDOR_UNKNOWN,
350 };
351
352 static void __cpuinit get_model_name(struct cpuinfo_x86 *c)
353 {
354         unsigned int *v;
355         char *p, *q;
356
357         if (c->extended_cpuid_level < 0x80000004)
358                 return;
359
360         v = (unsigned int *) c->x86_model_id;
361         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
362         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
363         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
364         c->x86_model_id[48] = 0;
365
366         /* Intel chips right-justify this string for some dumb reason;
367            undo that brain damage */
368         p = q = &c->x86_model_id[0];
369         while (*p == ' ')
370              p++;
371         if (p != q) {
372              while (*p)
373                   *q++ = *p++;
374              while (q <= &c->x86_model_id[48])
375                   *q++ = '\0';  /* Zero-pad the rest */
376         }
377 }
378
379 void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
380 {
381         unsigned int n, dummy, ebx, ecx, edx, l2size;
382
383         n = c->extended_cpuid_level;
384
385         if (n >= 0x80000005) {
386                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
387                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
388                                 edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
389                 c->x86_cache_size = (ecx>>24) + (edx>>24);
390 #ifdef CONFIG_X86_64
391                 /* On K8 L1 TLB is inclusive, so don't count it */
392                 c->x86_tlbsize = 0;
393 #endif
394         }
395
396         if (n < 0x80000006)     /* Some chips just has a large L1. */
397                 return;
398
399         cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
400         l2size = ecx >> 16;
401
402 #ifdef CONFIG_X86_64
403         c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
404 #else
405         /* do processor-specific cache resizing */
406         if (this_cpu->c_size_cache)
407                 l2size = this_cpu->c_size_cache(c, l2size);
408
409         /* Allow user to override all this if necessary. */
410         if (cachesize_override != -1)
411                 l2size = cachesize_override;
412
413         if (l2size == 0)
414                 return;         /* Again, no L2 cache is possible */
415 #endif
416
417         c->x86_cache_size = l2size;
418
419         printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
420                         l2size, ecx & 0xFF);
421 }
422
423 void __cpuinit detect_ht(struct cpuinfo_x86 *c)
424 {
425 #ifdef CONFIG_X86_HT
426         u32 eax, ebx, ecx, edx;
427         int index_msb, core_bits;
428
429         if (!cpu_has(c, X86_FEATURE_HT))
430                 return;
431
432         if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
433                 goto out;
434
435         if (cpu_has(c, X86_FEATURE_XTOPOLOGY))
436                 return;
437
438         cpuid(1, &eax, &ebx, &ecx, &edx);
439
440         smp_num_siblings = (ebx & 0xff0000) >> 16;
441
442         if (smp_num_siblings == 1) {
443                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
444         } else if (smp_num_siblings > 1) {
445
446                 if (smp_num_siblings > nr_cpu_ids) {
447                         printk(KERN_WARNING "CPU: Unsupported number of siblings %d",
448                                         smp_num_siblings);
449                         smp_num_siblings = 1;
450                         return;
451                 }
452
453                 index_msb = get_count_order(smp_num_siblings);
454                 c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb);
455
456                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
457
458                 index_msb = get_count_order(smp_num_siblings);
459
460                 core_bits = get_count_order(c->x86_max_cores);
461
462                 c->cpu_core_id = apic->phys_pkg_id(c->initial_apicid, index_msb) &
463                                                ((1 << core_bits) - 1);
464         }
465
466 out:
467         if ((c->x86_max_cores * smp_num_siblings) > 1) {
468                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
469                        c->phys_proc_id);
470                 printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
471                        c->cpu_core_id);
472         }
473 #endif
474 }
475
476 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
477 {
478         char *v = c->x86_vendor_id;
479         int i;
480         static int printed;
481
482         for (i = 0; i < X86_VENDOR_NUM; i++) {
483                 if (!cpu_devs[i])
484                         break;
485
486                 if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
487                     (cpu_devs[i]->c_ident[1] &&
488                      !strcmp(v, cpu_devs[i]->c_ident[1]))) {
489                         this_cpu = cpu_devs[i];
490                         c->x86_vendor = this_cpu->c_x86_vendor;
491                         return;
492                 }
493         }
494
495         if (!printed) {
496                 printed++;
497                 printk(KERN_ERR "CPU: vendor_id '%s' unknown, using generic init.\n", v);
498                 printk(KERN_ERR "CPU: Your system may be unstable.\n");
499         }
500
501         c->x86_vendor = X86_VENDOR_UNKNOWN;
502         this_cpu = &default_cpu;
503 }
504
505 void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
506 {
507         /* Get vendor name */
508         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
509               (unsigned int *)&c->x86_vendor_id[0],
510               (unsigned int *)&c->x86_vendor_id[8],
511               (unsigned int *)&c->x86_vendor_id[4]);
512
513         c->x86 = 4;
514         /* Intel-defined flags: level 0x00000001 */
515         if (c->cpuid_level >= 0x00000001) {
516                 u32 junk, tfms, cap0, misc;
517                 cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
518                 c->x86 = (tfms >> 8) & 0xf;
519                 c->x86_model = (tfms >> 4) & 0xf;
520                 c->x86_mask = tfms & 0xf;
521                 if (c->x86 == 0xf)
522                         c->x86 += (tfms >> 20) & 0xff;
523                 if (c->x86 >= 0x6)
524                         c->x86_model += ((tfms >> 16) & 0xf) << 4;
525                 if (cap0 & (1<<19)) {
526                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
527                         c->x86_cache_alignment = c->x86_clflush_size;
528                 }
529         }
530 }
531
532 static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c)
533 {
534         u32 tfms, xlvl;
535         u32 ebx;
536
537         /* Intel-defined flags: level 0x00000001 */
538         if (c->cpuid_level >= 0x00000001) {
539                 u32 capability, excap;
540                 cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
541                 c->x86_capability[0] = capability;
542                 c->x86_capability[4] = excap;
543         }
544
545         /* AMD-defined flags: level 0x80000001 */
546         xlvl = cpuid_eax(0x80000000);
547         c->extended_cpuid_level = xlvl;
548         if ((xlvl & 0xffff0000) == 0x80000000) {
549                 if (xlvl >= 0x80000001) {
550                         c->x86_capability[1] = cpuid_edx(0x80000001);
551                         c->x86_capability[6] = cpuid_ecx(0x80000001);
552                 }
553         }
554
555 #ifdef CONFIG_X86_64
556         if (c->extended_cpuid_level >= 0x80000008) {
557                 u32 eax = cpuid_eax(0x80000008);
558
559                 c->x86_virt_bits = (eax >> 8) & 0xff;
560                 c->x86_phys_bits = eax & 0xff;
561         }
562 #endif
563
564         if (c->extended_cpuid_level >= 0x80000007)
565                 c->x86_power = cpuid_edx(0x80000007);
566
567 }
568
569 static void __cpuinit identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
570 {
571 #ifdef CONFIG_X86_32
572         int i;
573
574         /*
575          * First of all, decide if this is a 486 or higher
576          * It's a 486 if we can modify the AC flag
577          */
578         if (flag_is_changeable_p(X86_EFLAGS_AC))
579                 c->x86 = 4;
580         else
581                 c->x86 = 3;
582
583         for (i = 0; i < X86_VENDOR_NUM; i++)
584                 if (cpu_devs[i] && cpu_devs[i]->c_identify) {
585                         c->x86_vendor_id[0] = 0;
586                         cpu_devs[i]->c_identify(c);
587                         if (c->x86_vendor_id[0]) {
588                                 get_cpu_vendor(c);
589                                 break;
590                         }
591                 }
592 #endif
593 }
594
595 /*
596  * Do minimum CPU detection early.
597  * Fields really needed: vendor, cpuid_level, family, model, mask,
598  * cache alignment.
599  * The others are not touched to avoid unwanted side effects.
600  *
601  * WARNING: this function is only called on the BP.  Don't add code here
602  * that is supposed to run on all CPUs.
603  */
604 static void __init early_identify_cpu(struct cpuinfo_x86 *c)
605 {
606 #ifdef CONFIG_X86_64
607         c->x86_clflush_size = 64;
608 #else
609         c->x86_clflush_size = 32;
610 #endif
611         c->x86_cache_alignment = c->x86_clflush_size;
612
613         memset(&c->x86_capability, 0, sizeof c->x86_capability);
614         c->extended_cpuid_level = 0;
615
616         if (!have_cpuid_p())
617                 identify_cpu_without_cpuid(c);
618
619         /* cyrix could have cpuid enabled via c_identify()*/
620         if (!have_cpuid_p())
621                 return;
622
623         cpu_detect(c);
624
625         get_cpu_vendor(c);
626
627         get_cpu_cap(c);
628
629         if (this_cpu->c_early_init)
630                 this_cpu->c_early_init(c);
631
632 #ifdef CONFIG_SMP
633         c->cpu_index = boot_cpu_id;
634 #endif
635         filter_cpuid_features(c, false);
636 }
637
638 void __init early_cpu_init(void)
639 {
640         struct cpu_dev **cdev;
641         int count = 0;
642
643         printk("KERNEL supported cpus:\n");
644         for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
645                 struct cpu_dev *cpudev = *cdev;
646                 unsigned int j;
647
648                 if (count >= X86_VENDOR_NUM)
649                         break;
650                 cpu_devs[count] = cpudev;
651                 count++;
652
653                 for (j = 0; j < 2; j++) {
654                         if (!cpudev->c_ident[j])
655                                 continue;
656                         printk("  %s %s\n", cpudev->c_vendor,
657                                 cpudev->c_ident[j]);
658                 }
659         }
660
661         early_identify_cpu(&boot_cpu_data);
662 }
663
664 /*
665  * The NOPL instruction is supposed to exist on all CPUs with
666  * family >= 6; unfortunately, that's not true in practice because
667  * of early VIA chips and (more importantly) broken virtualizers that
668  * are not easy to detect.  In the latter case it doesn't even *fail*
669  * reliably, so probing for it doesn't even work.  Disable it completely
670  * unless we can find a reliable way to detect all the broken cases.
671  */
672 static void __cpuinit detect_nopl(struct cpuinfo_x86 *c)
673 {
674         clear_cpu_cap(c, X86_FEATURE_NOPL);
675 }
676
677 static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
678 {
679         c->extended_cpuid_level = 0;
680
681         if (!have_cpuid_p())
682                 identify_cpu_without_cpuid(c);
683
684         /* cyrix could have cpuid enabled via c_identify()*/
685         if (!have_cpuid_p())
686                 return;
687
688         cpu_detect(c);
689
690         get_cpu_vendor(c);
691
692         get_cpu_cap(c);
693
694         if (c->cpuid_level >= 0x00000001) {
695                 c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xFF;
696 #ifdef CONFIG_X86_32
697 # ifdef CONFIG_X86_HT
698                 c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
699 # else
700                 c->apicid = c->initial_apicid;
701 # endif
702 #endif
703
704 #ifdef CONFIG_X86_HT
705                 c->phys_proc_id = c->initial_apicid;
706 #endif
707         }
708
709         get_model_name(c); /* Default name */
710
711         init_scattered_cpuid_features(c);
712         detect_nopl(c);
713 }
714
715 /*
716  * This does the hard work of actually picking apart the CPU stuff...
717  */
718 static void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
719 {
720         int i;
721
722         c->loops_per_jiffy = loops_per_jiffy;
723         c->x86_cache_size = -1;
724         c->x86_vendor = X86_VENDOR_UNKNOWN;
725         c->x86_model = c->x86_mask = 0; /* So far unknown... */
726         c->x86_vendor_id[0] = '\0'; /* Unset */
727         c->x86_model_id[0] = '\0';  /* Unset */
728         c->x86_max_cores = 1;
729         c->x86_coreid_bits = 0;
730 #ifdef CONFIG_X86_64
731         c->x86_clflush_size = 64;
732 #else
733         c->cpuid_level = -1;    /* CPUID not detected */
734         c->x86_clflush_size = 32;
735 #endif
736         c->x86_cache_alignment = c->x86_clflush_size;
737         memset(&c->x86_capability, 0, sizeof c->x86_capability);
738
739         generic_identify(c);
740
741         if (this_cpu->c_identify)
742                 this_cpu->c_identify(c);
743
744 #ifdef CONFIG_X86_64
745         c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
746 #endif
747
748         /*
749          * Vendor-specific initialization.  In this section we
750          * canonicalize the feature flags, meaning if there are
751          * features a certain CPU supports which CPUID doesn't
752          * tell us, CPUID claiming incorrect flags, or other bugs,
753          * we handle them here.
754          *
755          * At the end of this section, c->x86_capability better
756          * indicate the features this CPU genuinely supports!
757          */
758         if (this_cpu->c_init)
759                 this_cpu->c_init(c);
760
761         /* Disable the PN if appropriate */
762         squash_the_stupid_serial_number(c);
763
764         /*
765          * The vendor-specific functions might have changed features.  Now
766          * we do "generic changes."
767          */
768
769         /* Filter out anything that depends on CPUID levels we don't have */
770         filter_cpuid_features(c, true);
771
772         /* If the model name is still unset, do table lookup. */
773         if (!c->x86_model_id[0]) {
774                 char *p;
775                 p = table_lookup_model(c);
776                 if (p)
777                         strcpy(c->x86_model_id, p);
778                 else
779                         /* Last resort... */
780                         sprintf(c->x86_model_id, "%02x/%02x",
781                                 c->x86, c->x86_model);
782         }
783
784 #ifdef CONFIG_X86_64
785         detect_ht(c);
786 #endif
787
788         init_hypervisor(c);
789         /*
790          * On SMP, boot_cpu_data holds the common feature set between
791          * all CPUs; so make sure that we indicate which features are
792          * common between the CPUs.  The first time this routine gets
793          * executed, c == &boot_cpu_data.
794          */
795         if (c != &boot_cpu_data) {
796                 /* AND the already accumulated flags with these */
797                 for (i = 0; i < NCAPINTS; i++)
798                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
799         }
800
801         /* Clear all flags overriden by options */
802         for (i = 0; i < NCAPINTS; i++)
803                 c->x86_capability[i] &= ~cleared_cpu_caps[i];
804
805 #ifdef CONFIG_X86_MCE
806         /* Init Machine Check Exception if available. */
807         mcheck_init(c);
808 #endif
809
810         select_idle_routine(c);
811
812 #if defined(CONFIG_NUMA) && defined(CONFIG_X86_64)
813         numa_add_cpu(smp_processor_id());
814 #endif
815 }
816
817 #ifdef CONFIG_X86_64
818 static void vgetcpu_set_mode(void)
819 {
820         if (cpu_has(&boot_cpu_data, X86_FEATURE_RDTSCP))
821                 vgetcpu_mode = VGETCPU_RDTSCP;
822         else
823                 vgetcpu_mode = VGETCPU_LSL;
824 }
825 #endif
826
827 void __init identify_boot_cpu(void)
828 {
829         identify_cpu(&boot_cpu_data);
830 #ifdef CONFIG_X86_32
831         sysenter_setup();
832         enable_sep_cpu();
833 #else
834         vgetcpu_set_mode();
835 #endif
836         init_hw_perf_counters();
837 }
838
839 void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
840 {
841         BUG_ON(c == &boot_cpu_data);
842         identify_cpu(c);
843 #ifdef CONFIG_X86_32
844         enable_sep_cpu();
845 #endif
846         mtrr_ap_init();
847 }
848
849 struct msr_range {
850         unsigned min;
851         unsigned max;
852 };
853
854 static struct msr_range msr_range_array[] __cpuinitdata = {
855         { 0x00000000, 0x00000418},
856         { 0xc0000000, 0xc000040b},
857         { 0xc0010000, 0xc0010142},
858         { 0xc0011000, 0xc001103b},
859 };
860
861 static void __cpuinit print_cpu_msr(void)
862 {
863         unsigned index;
864         u64 val;
865         int i;
866         unsigned index_min, index_max;
867
868         for (i = 0; i < ARRAY_SIZE(msr_range_array); i++) {
869                 index_min = msr_range_array[i].min;
870                 index_max = msr_range_array[i].max;
871                 for (index = index_min; index < index_max; index++) {
872                         if (rdmsrl_amd_safe(index, &val))
873                                 continue;
874                         printk(KERN_INFO " MSR%08x: %016llx\n", index, val);
875                 }
876         }
877 }
878
879 static int show_msr __cpuinitdata;
880 static __init int setup_show_msr(char *arg)
881 {
882         int num;
883
884         get_option(&arg, &num);
885
886         if (num > 0)
887                 show_msr = num;
888         return 1;
889 }
890 __setup("show_msr=", setup_show_msr);
891
892 static __init int setup_noclflush(char *arg)
893 {
894         setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
895         return 1;
896 }
897 __setup("noclflush", setup_noclflush);
898
899 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
900 {
901         char *vendor = NULL;
902
903         if (c->x86_vendor < X86_VENDOR_NUM)
904                 vendor = this_cpu->c_vendor;
905         else if (c->cpuid_level >= 0)
906                 vendor = c->x86_vendor_id;
907
908         if (vendor && !strstr(c->x86_model_id, vendor))
909                 printk(KERN_CONT "%s ", vendor);
910
911         if (c->x86_model_id[0])
912                 printk(KERN_CONT "%s", c->x86_model_id);
913         else
914                 printk(KERN_CONT "%d86", c->x86);
915
916         if (c->x86_mask || c->cpuid_level >= 0)
917                 printk(KERN_CONT " stepping %02x\n", c->x86_mask);
918         else
919                 printk(KERN_CONT "\n");
920
921 #ifdef CONFIG_SMP
922         if (c->cpu_index < show_msr)
923                 print_cpu_msr();
924 #else
925         if (show_msr)
926                 print_cpu_msr();
927 #endif
928 }
929
930 static __init int setup_disablecpuid(char *arg)
931 {
932         int bit;
933         if (get_option(&arg, &bit) && bit < NCAPINTS*32)
934                 setup_clear_cpu_cap(bit);
935         else
936                 return 0;
937         return 1;
938 }
939 __setup("clearcpuid=", setup_disablecpuid);
940
941 #ifdef CONFIG_X86_64
942 struct desc_ptr idt_descr = { 256 * 16 - 1, (unsigned long) idt_table };
943
944 DEFINE_PER_CPU_FIRST(union irq_stack_union,
945                      irq_stack_union) __aligned(PAGE_SIZE);
946 DEFINE_PER_CPU(char *, irq_stack_ptr) =
947         init_per_cpu_var(irq_stack_union.irq_stack) + IRQ_STACK_SIZE - 64;
948
949 DEFINE_PER_CPU(unsigned long, kernel_stack) =
950         (unsigned long)&init_thread_union - KERNEL_STACK_OFFSET + THREAD_SIZE;
951 EXPORT_PER_CPU_SYMBOL(kernel_stack);
952
953 DEFINE_PER_CPU(unsigned int, irq_count) = -1;
954
955 static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks
956         [(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ])
957         __aligned(PAGE_SIZE);
958
959 extern asmlinkage void ignore_sysret(void);
960
961 /* May not be marked __init: used by software suspend */
962 void syscall_init(void)
963 {
964         /*
965          * LSTAR and STAR live in a bit strange symbiosis.
966          * They both write to the same internal register. STAR allows to
967          * set CS/DS but only a 32bit target. LSTAR sets the 64bit rip.
968          */
969         wrmsrl(MSR_STAR,  ((u64)__USER32_CS)<<48  | ((u64)__KERNEL_CS)<<32);
970         wrmsrl(MSR_LSTAR, system_call);
971         wrmsrl(MSR_CSTAR, ignore_sysret);
972
973 #ifdef CONFIG_IA32_EMULATION
974         syscall32_cpu_init();
975 #endif
976
977         /* Flags to clear on syscall */
978         wrmsrl(MSR_SYSCALL_MASK,
979                X86_EFLAGS_TF|X86_EFLAGS_DF|X86_EFLAGS_IF|X86_EFLAGS_IOPL);
980 }
981
982 unsigned long kernel_eflags;
983
984 /*
985  * Copies of the original ist values from the tss are only accessed during
986  * debugging, no special alignment required.
987  */
988 DEFINE_PER_CPU(struct orig_ist, orig_ist);
989
990 #else   /* x86_64 */
991
992 #ifdef CONFIG_CC_STACKPROTECTOR
993 DEFINE_PER_CPU(unsigned long, stack_canary);
994 #endif
995
996 /* Make sure %fs and %gs are initialized properly in idle threads */
997 struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
998 {
999         memset(regs, 0, sizeof(struct pt_regs));
1000         regs->fs = __KERNEL_PERCPU;
1001         regs->gs = __KERNEL_STACK_CANARY;
1002         return regs;
1003 }
1004 #endif  /* x86_64 */
1005
1006 /*
1007  * cpu_init() initializes state that is per-CPU. Some data is already
1008  * initialized (naturally) in the bootstrap process, such as the GDT
1009  * and IDT. We reload them nevertheless, this function acts as a
1010  * 'CPU state barrier', nothing should get across.
1011  * A lot of state is already set up in PDA init for 64 bit
1012  */
1013 #ifdef CONFIG_X86_64
1014 void __cpuinit cpu_init(void)
1015 {
1016         int cpu = stack_smp_processor_id();
1017         struct tss_struct *t = &per_cpu(init_tss, cpu);
1018         struct orig_ist *orig_ist = &per_cpu(orig_ist, cpu);
1019         unsigned long v;
1020         struct task_struct *me;
1021         int i;
1022
1023 #ifdef CONFIG_NUMA
1024         if (cpu != 0 && percpu_read(node_number) == 0 &&
1025             cpu_to_node(cpu) != NUMA_NO_NODE)
1026                 percpu_write(node_number, cpu_to_node(cpu));
1027 #endif
1028
1029         me = current;
1030
1031         if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask))
1032                 panic("CPU#%d already initialized!\n", cpu);
1033
1034         printk(KERN_INFO "Initializing CPU#%d\n", cpu);
1035
1036         clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);
1037
1038         /*
1039          * Initialize the per-CPU GDT with the boot GDT,
1040          * and set up the GDT descriptor:
1041          */
1042
1043         switch_to_new_gdt(cpu);
1044         loadsegment(fs, 0);
1045
1046         load_idt((const struct desc_ptr *)&idt_descr);
1047
1048         memset(me->thread.tls_array, 0, GDT_ENTRY_TLS_ENTRIES * 8);
1049         syscall_init();
1050
1051         wrmsrl(MSR_FS_BASE, 0);
1052         wrmsrl(MSR_KERNEL_GS_BASE, 0);
1053         barrier();
1054
1055         check_efer();
1056         if (cpu != 0 && x2apic)
1057                 enable_x2apic();
1058
1059         /*
1060          * set up and load the per-CPU TSS
1061          */
1062         if (!orig_ist->ist[0]) {
1063                 static const unsigned int sizes[N_EXCEPTION_STACKS] = {
1064                   [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ,
1065                   [DEBUG_STACK - 1] = DEBUG_STKSZ
1066                 };
1067                 char *estacks = per_cpu(exception_stacks, cpu);
1068                 for (v = 0; v < N_EXCEPTION_STACKS; v++) {
1069                         estacks += sizes[v];
1070                         orig_ist->ist[v] = t->x86_tss.ist[v] =
1071                                         (unsigned long)estacks;
1072                 }
1073         }
1074
1075         t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);
1076         /*
1077          * <= is required because the CPU will access up to
1078          * 8 bits beyond the end of the IO permission bitmap.
1079          */
1080         for (i = 0; i <= IO_BITMAP_LONGS; i++)
1081                 t->io_bitmap[i] = ~0UL;
1082
1083         atomic_inc(&init_mm.mm_count);
1084         me->active_mm = &init_mm;
1085         if (me->mm)
1086                 BUG();
1087         enter_lazy_tlb(&init_mm, me);
1088
1089         load_sp0(t, &current->thread);
1090         set_tss_desc(cpu, t);
1091         load_TR_desc();
1092         load_LDT(&init_mm.context);
1093
1094 #ifdef CONFIG_KGDB
1095         /*
1096          * If the kgdb is connected no debug regs should be altered.  This
1097          * is only applicable when KGDB and a KGDB I/O module are built
1098          * into the kernel and you are using early debugging with
1099          * kgdbwait. KGDB will control the kernel HW breakpoint registers.
1100          */
1101         if (kgdb_connected && arch_kgdb_ops.correct_hw_break)
1102                 arch_kgdb_ops.correct_hw_break();
1103         else
1104 #endif
1105         {
1106                 /*
1107                  * Clear all 6 debug registers:
1108                  */
1109                 set_debugreg(0UL, 0);
1110                 set_debugreg(0UL, 1);
1111                 set_debugreg(0UL, 2);
1112                 set_debugreg(0UL, 3);
1113                 set_debugreg(0UL, 6);
1114                 set_debugreg(0UL, 7);
1115         }
1116
1117         fpu_init();
1118
1119         raw_local_save_flags(kernel_eflags);
1120
1121         if (is_uv_system())
1122                 uv_cpu_init();
1123 }
1124
1125 #else
1126
1127 void __cpuinit cpu_init(void)
1128 {
1129         int cpu = smp_processor_id();
1130         struct task_struct *curr = current;
1131         struct tss_struct *t = &per_cpu(init_tss, cpu);
1132         struct thread_struct *thread = &curr->thread;
1133
1134         if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) {
1135                 printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
1136                 for (;;) local_irq_enable();
1137         }
1138
1139         printk(KERN_INFO "Initializing CPU#%d\n", cpu);
1140
1141         if (cpu_has_vme || cpu_has_tsc || cpu_has_de)
1142                 clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);
1143
1144         load_idt(&idt_descr);
1145         switch_to_new_gdt(cpu);
1146
1147         /*
1148          * Set up and load the per-CPU TSS and LDT
1149          */
1150         atomic_inc(&init_mm.mm_count);
1151         curr->active_mm = &init_mm;
1152         if (curr->mm)
1153                 BUG();
1154         enter_lazy_tlb(&init_mm, curr);
1155
1156         load_sp0(t, thread);
1157         set_tss_desc(cpu, t);
1158         load_TR_desc();
1159         load_LDT(&init_mm.context);
1160
1161 #ifdef CONFIG_DOUBLEFAULT
1162         /* Set up doublefault TSS pointer in the GDT */
1163         __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
1164 #endif
1165
1166         /* Clear all 6 debug registers: */
1167         set_debugreg(0, 0);
1168         set_debugreg(0, 1);
1169         set_debugreg(0, 2);
1170         set_debugreg(0, 3);
1171         set_debugreg(0, 6);
1172         set_debugreg(0, 7);
1173
1174         /*
1175          * Force FPU initialization:
1176          */
1177         if (cpu_has_xsave)
1178                 current_thread_info()->status = TS_XSAVE;
1179         else
1180                 current_thread_info()->status = 0;
1181         clear_used_math();
1182         mxcsr_feature_mask_init();
1183
1184         /*
1185          * Boot processor to setup the FP and extended state context info.
1186          */
1187         if (smp_processor_id() == boot_cpu_id)
1188                 init_thread_xstate();
1189
1190         xsave_init();
1191 }
1192
1193
1194 #endif