common.c 18 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6
#include <linux/init.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/smp.h>
#include <linux/module.h>
#include <linux/percpu.h>
7
#include <linux/bootmem.h>
Linus Torvalds's avatar
Linus Torvalds committed
8 9 10 11 12
#include <asm/processor.h>
#include <asm/i387.h>
#include <asm/msr.h>
#include <asm/io.h>
#include <asm/mmu_context.h>
13
#include <asm/mtrr.h>
14
#include <asm/mce.h>
15
#include <asm/pat.h>
Linus Torvalds's avatar
Linus Torvalds committed
16 17 18 19 20 21 22 23
#ifdef CONFIG_X86_LOCAL_APIC
#include <asm/mpspec.h>
#include <asm/apic.h>
#include <mach_apic.h>
#endif

#include "cpu.h"

24
DEFINE_PER_CPU(struct gdt_page, gdt_page) = { .gdt = {
25 26 27 28
	[GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } },
	[GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } },
	[GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } },
	[GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } },
29 30 31 32 33
	/*
	 * Segments used for calling PnP BIOS have byte granularity.
	 * They code segments and data segments have fixed 64k limits,
	 * the transfer segment sizes are set at run time.
	 */
34 35 36 37 38 39 40 41 42 43
	/* 32-bit code */
	[GDT_ENTRY_PNPBIOS_CS32] = { { { 0x0000ffff, 0x00409a00 } } },
	/* 16-bit code */
	[GDT_ENTRY_PNPBIOS_CS16] = { { { 0x0000ffff, 0x00009a00 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_DS] = { { { 0x0000ffff, 0x00009200 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_TS1] = { { { 0x00000000, 0x00009200 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_TS2] = { { { 0x00000000, 0x00009200 } } },
44 45 46 47
	/*
	 * The APM segments have byte granularity and their bases
	 * are set at run time.  All have 64k limits.
	 */
48 49
	/* 32-bit code */
	[GDT_ENTRY_APMBIOS_BASE] = { { { 0x0000ffff, 0x00409a00 } } },
50
	/* 16-bit code */
51 52 53
	[GDT_ENTRY_APMBIOS_BASE+1] = { { { 0x0000ffff, 0x00009a00 } } },
	/* data */
	[GDT_ENTRY_APMBIOS_BASE+2] = { { { 0x0000ffff, 0x00409200 } } },
54

55 56
	[GDT_ENTRY_ESPFIX_SS] = { { { 0x00000000, 0x00c09200 } } },
	[GDT_ENTRY_PERCPU] = { { { 0x00000000, 0x00000000 } } },
57 58
} };
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
59

60 61
__u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;

62 63
static int cachesize_override __cpuinitdata = -1;
static int disable_x86_serial_nr __cpuinitdata = 1;
Linus Torvalds's avatar
Linus Torvalds committed
64

65
struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
Linus Torvalds's avatar
Linus Torvalds committed
66

67
static void __cpuinit default_init(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72 73 74 75 76 77 78 79
{
	/* Not much we can do here... */
	/* Check if at least it has cpuid */
	if (c->cpuid_level == -1) {
		/* No cpuid. It must be an ancient CPU */
		if (c->x86 == 4)
			strcpy(c->x86_model_id, "486");
		else if (c->x86 == 3)
			strcpy(c->x86_model_id, "386");
	}
}

80
static struct cpu_dev __cpuinitdata default_cpu = {
Linus Torvalds's avatar
Linus Torvalds committed
81
	.c_init	= default_init,
82
	.c_vendor = "Unknown",
Linus Torvalds's avatar
Linus Torvalds committed
83
};
84
static struct cpu_dev *this_cpu __cpuinitdata = &default_cpu;
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87

static int __init cachesize_setup(char *str)
{
88
	get_option(&str, &cachesize_override);
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92
	return 1;
}
__setup("cachesize=", cachesize_setup);

93
int __cpuinit get_model_name(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
{
	unsigned int *v;
	char *p, *q;

	if (cpuid_eax(0x80000000) < 0x80000004)
		return 0;

	v = (unsigned int *) c->x86_model_id;
	cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
	cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
	cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
	c->x86_model_id[48] = 0;

	/* Intel chips right-justify this string for some dumb reason;
	   undo that brain damage */
	p = q = &c->x86_model_id[0];
110
	while (*p == ' ')
Linus Torvalds's avatar
Linus Torvalds committed
111
	     p++;
112 113
	if (p != q) {
	     while (*p)
Linus Torvalds's avatar
Linus Torvalds committed
114
		  *q++ = *p++;
115
	     while (q <= &c->x86_model_id[48])
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120 121 122
		  *q++ = '\0';	/* Zero-pad the rest */
	}

	return 1;
}


123
void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
124 125 126 127 128 129 130 131 132
{
	unsigned int n, dummy, ecx, edx, l2size;

	n = cpuid_eax(0x80000000);

	if (n >= 0x80000005) {
		cpuid(0x80000005, &dummy, &dummy, &ecx, &edx);
		printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
			edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
133
		c->x86_cache_size = (ecx>>24)+(edx>>24);
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139 140
	}

	if (n < 0x80000006)	/* Some chips just has a large L1. */
		return;

	ecx = cpuid_ecx(0x80000006);
	l2size = ecx >> 16;
141

Linus Torvalds's avatar
Linus Torvalds committed
142 143
	/* do processor-specific cache resizing */
	if (this_cpu->c_size_cache)
144
		l2size = this_cpu->c_size_cache(c, l2size);
Linus Torvalds's avatar
Linus Torvalds committed
145 146 147 148 149

	/* Allow user to override all this if necessary. */
	if (cachesize_override != -1)
		l2size = cachesize_override;

150
	if (l2size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153 154 155 156 157 158
		return;		/* Again, no L2 cache is possible */

	c->x86_cache_size = l2size;

	printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
	       l2size, ecx & 0xFF);
}

159 160 161 162 163 164
/*
 * Naming convention should be: <Name> [(<Codename>)]
 * This table only is used unless init_<vendor>() below doesn't set it;
 * in particular, if CPUID levels 0x80000002..4 are supported, this isn't used
 *
 */
Linus Torvalds's avatar
Linus Torvalds committed
165 166

/* Look up CPU names by table lookup. */
167
static char __cpuinit *table_lookup_model(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
168 169 170
{
	struct cpu_model_info *info;

171
	if (c->x86_model >= 16)
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
		return NULL;	/* Range check */

	if (!this_cpu)
		return NULL;

	info = this_cpu->c_models;

	while (info && info->family) {
		if (info->family == c->x86)
			return info->model_names[c->x86_model];
		info++;
	}
	return NULL;		/* Not found */
}


188
static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c, int early)
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191
{
	char *v = c->x86_vendor_id;
	int i;
192
	static int printed;
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195

	for (i = 0; i < X86_VENDOR_NUM; i++) {
		if (cpu_devs[i]) {
196 197 198
			if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
			    (cpu_devs[i]->c_ident[1] &&
			     !strcmp(v, cpu_devs[i]->c_ident[1]))) {
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201
				c->x86_vendor = i;
				if (!early)
					this_cpu = cpu_devs[i];
202
				return;
Linus Torvalds's avatar
Linus Torvalds committed
203 204 205
			}
		}
	}
206 207 208 209 210 211 212
	if (!printed) {
		printed++;
		printk(KERN_ERR "CPU: Vendor unknown, using generic init.\n");
		printk(KERN_ERR "CPU: Your system may be unstable.\n");
	}
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	this_cpu = &default_cpu;
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215
}


216
static int __init x86_fxsr_setup(char *s)
Linus Torvalds's avatar
Linus Torvalds committed
217
{
218 219
	setup_clear_cpu_cap(X86_FEATURE_FXSR);
	setup_clear_cpu_cap(X86_FEATURE_XMM);
Linus Torvalds's avatar
Linus Torvalds committed
220 221 222 223 224
	return 1;
}
__setup("nofxsr", x86_fxsr_setup);


225
static int __init x86_sep_setup(char *s)
226
{
227
	setup_clear_cpu_cap(X86_FEATURE_SEP);
228 229 230 231 232
	return 1;
}
__setup("nosep", x86_sep_setup);


Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
/* Standard macro to see if a specific flag is changeable */
static inline int flag_is_changeable_p(u32 flag)
{
	u32 f1, f2;

	asm("pushfl\n\t"
	    "pushfl\n\t"
	    "popl %0\n\t"
	    "movl %0,%1\n\t"
	    "xorl %2,%0\n\t"
	    "pushl %0\n\t"
	    "popfl\n\t"
	    "pushfl\n\t"
	    "popl %0\n\t"
	    "popfl\n\t"
	    : "=&r" (f1), "=&r" (f2)
	    : "ir" (flag));

	return ((f1^f2) & flag) != 0;
}


/* Probe for the CPUID instruction */
256
static int __cpuinit have_cpuid_p(void)
Linus Torvalds's avatar
Linus Torvalds committed
257 258 259 260
{
	return flag_is_changeable_p(X86_EFLAGS_ID);
}

261
void __init cpu_detect(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
262 263
{
	/* Get vendor name */
264 265 266 267
	cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
	      (unsigned int *)&c->x86_vendor_id[0],
	      (unsigned int *)&c->x86_vendor_id[8],
	      (unsigned int *)&c->x86_vendor_id[4]);
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270 271 272 273 274

	c->x86 = 4;
	if (c->cpuid_level >= 0x00000001) {
		u32 junk, tfms, cap0, misc;
		cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
		c->x86 = (tfms >> 8) & 15;
		c->x86_model = (tfms >> 4) & 15;
275
		if (c->x86 == 0xf)
Linus Torvalds's avatar
Linus Torvalds committed
276
			c->x86 += (tfms >> 20) & 0xff;
277
		if (c->x86 >= 0x6)
Linus Torvalds's avatar
Linus Torvalds committed
278 279
			c->x86_model += ((tfms >> 16) & 0xF) << 4;
		c->x86_mask = tfms & 15;
280
		if (cap0 & (1<<19)) {
Linus Torvalds's avatar
Linus Torvalds committed
281
			c->x86_cache_alignment = ((misc >> 8) & 0xff) * 8;
282 283
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
		}
Linus Torvalds's avatar
Linus Torvalds committed
284 285
	}
}
286 287 288
static void __cpuinit early_get_cap(struct cpuinfo_x86 *c)
{
	u32 tfms, xlvl;
289
	unsigned int ebx;
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312

	memset(&c->x86_capability, 0, sizeof c->x86_capability);
	if (have_cpuid_p()) {
		/* Intel-defined flags: level 0x00000001 */
		if (c->cpuid_level >= 0x00000001) {
			u32 capability, excap;
			cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
			c->x86_capability[0] = capability;
			c->x86_capability[4] = excap;
		}

		/* AMD-defined flags: level 0x80000001 */
		xlvl = cpuid_eax(0x80000000);
		if ((xlvl & 0xffff0000) == 0x80000000) {
			if (xlvl >= 0x80000001) {
				c->x86_capability[1] = cpuid_edx(0x80000001);
				c->x86_capability[6] = cpuid_ecx(0x80000001);
			}
		}

	}

}
Linus Torvalds's avatar
Linus Torvalds committed
313

314 315 316 317 318 319 320 321 322
/*
 * Do minimum CPU detection early.
 * Fields really needed: vendor, cpuid_level, family, model, mask,
 * cache alignment.
 * The others are not touched to avoid unwanted side effects.
 *
 * WARNING: this function is only called on the BP.  Don't add code here
 * that is supposed to run on all CPUs.
 */
323 324 325 326 327
static void __init early_cpu_detect(void)
{
	struct cpuinfo_x86 *c = &boot_cpu_data;

	c->x86_cache_alignment = 32;
328
	c->x86_clflush_size = 32;
329 330 331 332 333 334 335

	if (!have_cpuid_p())
		return;

	cpu_detect(c);

	get_cpu_vendor(c, 1);
336

337 338 339
	if (c->x86_vendor != X86_VENDOR_UNKNOWN &&
	    cpu_devs[c->x86_vendor]->c_early_init)
		cpu_devs[c->x86_vendor]->c_early_init(c);
340 341

	early_get_cap(c);
342 343
}

344
static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
345 346
{
	u32 tfms, xlvl;
347
	unsigned int ebx;
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350

	if (have_cpuid_p()) {
		/* Get vendor name */
351 352 353 354
		cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
		      (unsigned int *)&c->x86_vendor_id[0],
		      (unsigned int *)&c->x86_vendor_id[8],
		      (unsigned int *)&c->x86_vendor_id[4]);
355

Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359
		get_cpu_vendor(c, 0);
		/* Initialize the standard set of capabilities */
		/* Note that the vendor-specific code below might override */
		/* Intel-defined flags: level 0x00000001 */
360
		if (c->cpuid_level >= 0x00000001) {
Linus Torvalds's avatar
Linus Torvalds committed
361
			u32 capability, excap;
362
			cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366
			c->x86_capability[0] = capability;
			c->x86_capability[4] = excap;
			c->x86 = (tfms >> 8) & 15;
			c->x86_model = (tfms >> 4) & 15;
367
			if (c->x86 == 0xf)
Linus Torvalds's avatar
Linus Torvalds committed
368
				c->x86 += (tfms >> 20) & 0xff;
369
			if (c->x86 >= 0x6)
Linus Torvalds's avatar
Linus Torvalds committed
370 371
				c->x86_model += ((tfms >> 16) & 0xF) << 4;
			c->x86_mask = tfms & 15;
Yinghai Lu's avatar
Yinghai Lu committed
372
			c->initial_apicid = (ebx >> 24) & 0xFF;
373
#ifdef CONFIG_X86_HT
Yinghai Lu's avatar
Yinghai Lu committed
374 375
			c->apicid = phys_pkg_id(c->initial_apicid, 0);
			c->phys_proc_id = c->initial_apicid;
376
#else
Yinghai Lu's avatar
Yinghai Lu committed
377
			c->apicid = c->initial_apicid;
378
#endif
379
			if (test_cpu_cap(c, X86_FEATURE_CLFLSH))
380
				c->x86_clflush_size = ((ebx >> 8) & 0xff) * 8;
Linus Torvalds's avatar
Linus Torvalds committed
381 382 383 384 385 386 387
		} else {
			/* Have CPUID level 0 only - unheard of */
			c->x86 = 4;
		}

		/* AMD-defined flags: level 0x80000001 */
		xlvl = cpuid_eax(0x80000000);
388 389
		if ((xlvl & 0xffff0000) == 0x80000000) {
			if (xlvl >= 0x80000001) {
Linus Torvalds's avatar
Linus Torvalds committed
390 391 392
				c->x86_capability[1] = cpuid_edx(0x80000001);
				c->x86_capability[6] = cpuid_ecx(0x80000001);
			}
393
			if (xlvl >= 0x80000004)
Linus Torvalds's avatar
Linus Torvalds committed
394 395
				get_model_name(c); /* Default name */
		}
396 397

		init_scattered_cpuid_features(c);
Linus Torvalds's avatar
Linus Torvalds committed
398
	}
399

Linus Torvalds's avatar
Linus Torvalds committed
400 401
}

402
static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
403
{
404
	if (cpu_has(c, X86_FEATURE_PN) && disable_x86_serial_nr) {
Linus Torvalds's avatar
Linus Torvalds committed
405
		/* Disable processor serial number */
406 407
		unsigned long lo, hi;
		rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
Linus Torvalds's avatar
Linus Torvalds committed
408
		lo |= 0x200000;
409
		wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
Linus Torvalds's avatar
Linus Torvalds committed
410
		printk(KERN_NOTICE "CPU serial number disabled.\n");
411
		clear_cpu_cap(c, X86_FEATURE_PN);
Linus Torvalds's avatar
Linus Torvalds committed
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429

		/* Disabling the serial number may affect the cpuid level */
		c->cpuid_level = cpuid_eax(0);
	}
}

static int __init x86_serial_nr_setup(char *s)
{
	disable_x86_serial_nr = 0;
	return 1;
}
__setup("serialnumber", x86_serial_nr_setup);



/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
430
static void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434 435 436 437 438 439 440
{
	int i;

	c->loops_per_jiffy = loops_per_jiffy;
	c->x86_cache_size = -1;
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	c->cpuid_level = -1;	/* CPUID not detected */
	c->x86_model = c->x86_mask = 0;	/* So far unknown... */
	c->x86_vendor_id[0] = '\0'; /* Unset */
	c->x86_model_id[0] = '\0';  /* Unset */
441
	c->x86_max_cores = 1;
442
	c->x86_clflush_size = 32;
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

	if (!have_cpuid_p()) {
446 447 448 449 450
		/*
		 * First of all, decide if this is a 486 or higher
		 * It's a 486 if we can modify the AC flag
		 */
		if (flag_is_changeable_p(X86_EFLAGS_AC))
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455 456 457
			c->x86 = 4;
		else
			c->x86 = 3;
	}

	generic_identify(c);

458
	if (this_cpu->c_identify)
Linus Torvalds's avatar
Linus Torvalds committed
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
		this_cpu->c_identify(c);

	/*
	 * Vendor-specific initialization.  In this section we
	 * canonicalize the feature flags, meaning if there are
	 * features a certain CPU supports which CPUID doesn't
	 * tell us, CPUID claiming incorrect flags, or other bugs,
	 * we handle them here.
	 *
	 * At the end of this section, c->x86_capability better
	 * indicate the features this CPU genuinely supports!
	 */
	if (this_cpu->c_init)
		this_cpu->c_init(c);

	/* Disable the PN if appropriate */
	squash_the_stupid_serial_number(c);

	/*
	 * The vendor-specific functions might have changed features.  Now
	 * we do "generic changes."
	 */

	/* If the model name is still unset, do table lookup. */
483
	if (!c->x86_model_id[0]) {
Linus Torvalds's avatar
Linus Torvalds committed
484 485
		char *p;
		p = table_lookup_model(c);
486
		if (p)
Linus Torvalds's avatar
Linus Torvalds committed
487 488 489 490
			strcpy(c->x86_model_id, p);
		else
			/* Last resort... */
			sprintf(c->x86_model_id, "%02x/%02x",
491
				c->x86, c->x86_model);
Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496 497 498 499
	}

	/*
	 * On SMP, boot_cpu_data holds the common feature set between
	 * all CPUs; so make sure that we indicate which features are
	 * common between the CPUs.  The first time this routine gets
	 * executed, c == &boot_cpu_data.
	 */
500
	if (c != &boot_cpu_data) {
Linus Torvalds's avatar
Linus Torvalds committed
501
		/* AND the already accumulated flags with these */
502
		for (i = 0 ; i < NCAPINTS ; i++)
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
	}

506 507
	/* Clear all flags overriden by options */
	for (i = 0; i < NCAPINTS; i++)
508
		c->x86_capability[i] &= ~cleared_cpu_caps[i];
509

Linus Torvalds's avatar
Linus Torvalds committed
510 511
	/* Init Machine Check Exception if available. */
	mcheck_init(c);
512 513

	select_idle_routine(c);
514
}
Shaohua Li's avatar
Shaohua Li committed
515

516 517 518 519
void __init identify_boot_cpu(void)
{
	identify_cpu(&boot_cpu_data);
	sysenter_setup();
Li Shaohua's avatar
Li Shaohua committed
520
	enable_sep_cpu();
521
}
522

523 524 525 526 527 528
void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
{
	BUG_ON(c == &boot_cpu_data);
	identify_cpu(c);
	enable_sep_cpu();
	mtrr_ap_init();
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531
}

#ifdef CONFIG_X86_HT
532
void __cpuinit detect_ht(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
533 534
{
	u32 	eax, ebx, ecx, edx;
535
	int 	index_msb, core_bits;
Linus Torvalds's avatar
Linus Torvalds committed
536

537 538
	cpuid(1, &eax, &ebx, &ecx, &edx);

539
	if (!cpu_has(c, X86_FEATURE_HT) || cpu_has(c, X86_FEATURE_CMP_LEGACY))
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542 543 544 545
		return;

	smp_num_siblings = (ebx & 0xff0000) >> 16;

	if (smp_num_siblings == 1) {
		printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
546
	} else if (smp_num_siblings > 1) {
Linus Torvalds's avatar
Linus Torvalds committed
547 548

		if (smp_num_siblings > NR_CPUS) {
549 550
			printk(KERN_WARNING "CPU: Unsupported number of the "
					"siblings %d", smp_num_siblings);
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553
			smp_num_siblings = 1;
			return;
		}
554 555

		index_msb = get_count_order(smp_num_siblings);
Yinghai Lu's avatar
Yinghai Lu committed
556
		c->phys_proc_id = phys_pkg_id(c->initial_apicid, index_msb);
Linus Torvalds's avatar
Linus Torvalds committed
557 558

		printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
559
		       c->phys_proc_id);
560

561
		smp_num_siblings = smp_num_siblings / c->x86_max_cores;
562

563
		index_msb = get_count_order(smp_num_siblings) ;
564

565
		core_bits = get_count_order(c->x86_max_cores);
566

Yinghai Lu's avatar
Yinghai Lu committed
567
		c->cpu_core_id = phys_pkg_id(c->initial_apicid, index_msb) &
568
					       ((1 << core_bits) - 1);
569

570
		if (c->x86_max_cores > 1)
571
			printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
572
			       c->cpu_core_id);
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575 576
	}
}
#endif

Andi Kleen's avatar
Andi Kleen committed
577 578 579 580 581 582 583
static __init int setup_noclflush(char *arg)
{
	setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
	return 1;
}
__setup("noclflush", setup_noclflush);

584
void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
{
	char *vendor = NULL;

	if (c->x86_vendor < X86_VENDOR_NUM)
		vendor = this_cpu->c_vendor;
	else if (c->cpuid_level >= 0)
		vendor = c->x86_vendor_id;

	if (vendor && strncmp(c->x86_model_id, vendor, strlen(vendor)))
		printk("%s ", vendor);

	if (!c->x86_model_id[0])
		printk("%d86", c->x86);
	else
		printk("%s", c->x86_model_id);

601
	if (c->x86_mask || c->cpuid_level >= 0)
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606
		printk(" stepping %02x\n", c->x86_mask);
	else
		printk("\n");
}

607 608 609 610 611 612 613 614 615 616 617
static __init int setup_disablecpuid(char *arg)
{
	int bit;
	if (get_option(&arg, &bit) && bit < NCAPINTS*32)
		setup_clear_cpu_cap(bit);
	else
		return 0;
	return 1;
}
__setup("clearcpuid=", setup_disablecpuid);

618
cpumask_t cpu_initialized __cpuinitdata = CPU_MASK_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
619 620 621

void __init early_cpu_init(void)
{
622 623 624 625 626 627 628
	struct cpu_vendor_dev *cvdev;

	for (cvdev = __x86cpuvendor_start ;
	     cvdev < __x86cpuvendor_end   ;
	     cvdev++)
		cpu_devs[cvdev->vendor] = cvdev->cpu_dev;

Linus Torvalds's avatar
Linus Torvalds committed
629
	early_cpu_detect();
630
	validate_pat_support(&boot_cpu_data);
Linus Torvalds's avatar
Linus Torvalds committed
631
}
632

633
/* Make sure %fs is initialized properly in idle threads */
Adrian Bunk's avatar
Adrian Bunk committed
634
struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
635 636
{
	memset(regs, 0, sizeof(struct pt_regs));
637
	regs->fs = __KERNEL_PERCPU;
638 639 640
	return regs;
}

641 642 643 644
/* Current gdt points %fs at the "master" per-cpu area: after this,
 * it's on the real one. */
void switch_to_new_gdt(void)
{
645
	struct desc_ptr gdt_descr;
646 647 648 649 650 651 652

	gdt_descr.address = (long)get_cpu_gdt_table(smp_processor_id());
	gdt_descr.size = GDT_SIZE - 1;
	load_gdt(&gdt_descr);
	asm("mov %0, %%fs" : : "r" (__KERNEL_PERCPU) : "memory");
}

653 654 655 656 657 658 659
/*
 * cpu_init() initializes state that is per-CPU. Some data is already
 * initialized (naturally) in the bootstrap process, such as the GDT
 * and IDT. We reload them nevertheless, this function acts as a
 * 'CPU state barrier', nothing should get across.
 */
void __cpuinit cpu_init(void)
660
{
661 662
	int cpu = smp_processor_id();
	struct task_struct *curr = current;
663
	struct tss_struct *t = &per_cpu(init_tss, cpu);
664
	struct thread_struct *thread = &curr->thread;
665 666 667 668 669 670 671 672 673 674 675

	if (cpu_test_and_set(cpu, cpu_initialized)) {
		printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
		for (;;) local_irq_enable();
	}

	printk(KERN_INFO "Initializing CPU#%d\n", cpu);

	if (cpu_has_vme || cpu_has_tsc || cpu_has_de)
		clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);

676
	load_idt(&idt_descr);
677
	switch_to_new_gdt();
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680 681 682

	/*
	 * Set up and load the per-CPU TSS and LDT
	 */
	atomic_inc(&init_mm.mm_count);
683 684 685 686
	curr->active_mm = &init_mm;
	if (curr->mm)
		BUG();
	enter_lazy_tlb(&init_mm, curr);
Linus Torvalds's avatar
Linus Torvalds committed
687

688
	load_sp0(t, thread);
689
	set_tss_desc(cpu, t);
Linus Torvalds's avatar
Linus Torvalds committed
690 691 692
	load_TR_desc();
	load_LDT(&init_mm.context);

693
#ifdef CONFIG_DOUBLEFAULT
Linus Torvalds's avatar
Linus Torvalds committed
694 695
	/* Set up doublefault TSS pointer in the GDT */
	__set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
696
#endif
Linus Torvalds's avatar
Linus Torvalds committed
697

698 699
	/* Clear %gs. */
	asm volatile ("mov %0, %%gs" : : "r" (0));
Linus Torvalds's avatar
Linus Torvalds committed
700 701

	/* Clear all 6 debug registers: */
702 703 704 705 706 707
	set_debugreg(0, 0);
	set_debugreg(0, 1);
	set_debugreg(0, 2);
	set_debugreg(0, 3);
	set_debugreg(0, 6);
	set_debugreg(0, 7);
Linus Torvalds's avatar
Linus Torvalds committed
708 709 710 711

	/*
	 * Force FPU initialization:
	 */
712 713 714 715
	if (cpu_has_xsave)
		current_thread_info()->status = TS_XSAVE;
	else
		current_thread_info()->status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
716 717
	clear_used_math();
	mxcsr_feature_mask_init();
718 719 720 721 722 723 724 725

	/*
	 * Boot processor to setup the FP and extended state context info.
	 */
	if (!smp_processor_id())
		init_thread_xstate();

	xsave_init();
Linus Torvalds's avatar
Linus Torvalds committed
726
}
727 728

#ifdef CONFIG_HOTPLUG_CPU
729
void __cpuinit cpu_uninit(void)
730 731 732 733 734 735 736 737 738
{
	int cpu = raw_smp_processor_id();
	cpu_clear(cpu, cpu_initialized);

	/* lazy TLB state */
	per_cpu(cpu_tlbstate, cpu).state = 0;
	per_cpu(cpu_tlbstate, cpu).active_mm = &init_mm;
}
#endif