setup.c 27.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *  linux/arch/x86-64/kernel/setup.c
 *
 *  Copyright (C) 1995  Linus Torvalds
 *
 *  Nov 2001 Dave Jones <davej@suse.de>
 *  Forked from i386 setup code.
 */

/*
 * This file handles the architecture-dependent parts of initialization
 */

#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/user.h>
#include <linux/a.out.h>
24
#include <linux/screen_info.h>
L
Linus Torvalds 已提交
25 26 27 28 29 30 31 32 33 34
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/initrd.h>
#include <linux/highmem.h>
#include <linux/bootmem.h>
#include <linux/module.h>
#include <asm/processor.h>
#include <linux/console.h>
#include <linux/seq_file.h>
35
#include <linux/crash_dump.h>
L
Linus Torvalds 已提交
36 37 38 39 40
#include <linux/root_dev.h>
#include <linux/pci.h>
#include <linux/acpi.h>
#include <linux/kallsyms.h>
#include <linux/edd.h>
41
#include <linux/mmzone.h>
42
#include <linux/kexec.h>
43
#include <linux/cpufreq.h>
44
#include <linux/dmi.h>
45
#include <linux/dma-mapping.h>
46
#include <linux/ctype.h>
47

L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
#include <asm/mtrr.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/smp.h>
#include <asm/msr.h>
#include <asm/desc.h>
#include <video/edid.h>
#include <asm/e820.h>
#include <asm/dma.h>
#include <asm/mpspec.h>
#include <asm/mmu_context.h>
#include <asm/bootsetup.h>
#include <asm/proto.h>
#include <asm/setup.h>
#include <asm/mach_apic.h>
#include <asm/numa.h>
65
#include <asm/sections.h>
66
#include <asm/dmi.h>
L
Linus Torvalds 已提交
67 68 69 70 71

/*
 * Machine setup..
 */

72
struct cpuinfo_x86 boot_cpu_data __read_mostly;
73
EXPORT_SYMBOL(boot_cpu_data);
L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81

unsigned long mmu_cr4_features;

/* Boot loader ID as an integer, for the benefit of proc_dointvec */
int bootloader_type;

unsigned long saved_video_mode;

82 83
int force_mwait __cpuinitdata;

84 85 86 87 88 89
/* 
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

L
Linus Torvalds 已提交
90 91 92 93
/*
 * Setup options
 */
struct screen_info screen_info;
94
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
95 96 97 98 99 100
struct sys_desc_table_struct {
	unsigned short length;
	unsigned char table[0];
};

struct edid_info edid_info;
101
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
102 103 104

extern int root_mountflags;

105
char __initdata command_line[COMMAND_LINE_SIZE];
L
Linus Torvalds 已提交
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

struct resource standard_io_resources[] = {
	{ .name = "dma1", .start = 0x00, .end = 0x1f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic1", .start = 0x20, .end = 0x21,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer0", .start = 0x40, .end = 0x43,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer1", .start = 0x50, .end = 0x53,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x60, .end = 0x6f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma page reg", .start = 0x80, .end = 0x8f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic2", .start = 0xa0, .end = 0xa1,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma2", .start = 0xc0, .end = 0xdf,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "fpu", .start = 0xf0, .end = 0xff,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO }
};

#define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)

struct resource data_resource = {
	.name = "Kernel data",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
};
struct resource code_resource = {
	.name = "Kernel code",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
};

143 144 145 146 147 148
#ifdef CONFIG_PROC_VMCORE
/* elfcorehdr= specifies the location of elf core header
 * stored by the crashed kernel. This option will be passed
 * by kexec loader to the capture kernel.
 */
static int __init setup_elfcorehdr(char *arg)
149
{
150 151 152 153 154
	char *end;
	if (!arg)
		return -EINVAL;
	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
155
}
156
early_param("elfcorehdr", setup_elfcorehdr);
157 158
#endif

159
#ifndef CONFIG_NUMA
160 161
static void __init
contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
L
Linus Torvalds 已提交
162
{
163 164 165 166 167 168 169
	unsigned long bootmap_size, bootmap;

	bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
	bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
	if (bootmap == -1L)
		panic("Cannot find bootmem map of size %ld\n",bootmap_size);
	bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
170 171
	e820_register_active_regions(0, start_pfn, end_pfn);
	free_bootmem_with_active_regions(0, end_pfn);
172
	reserve_bootmem(bootmap, bootmap_size);
L
Linus Torvalds 已提交
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
} 
#endif

#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
struct edd edd;
#ifdef CONFIG_EDD_MODULE
EXPORT_SYMBOL(edd);
#endif
/**
 * copy_edd() - Copy the BIOS EDD information
 *              from boot_params into a safe place.
 *
 */
static inline void copy_edd(void)
{
     memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
     memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
     edd.mbr_signature_nr = EDD_MBR_SIG_NR;
     edd.edd_info_nr = EDD_NR;
}
#else
static inline void copy_edd(void)
{
}
#endif

#define EBDA_ADDR_POINTER 0x40E
200 201 202 203 204

unsigned __initdata ebda_addr;
unsigned __initdata ebda_size;

static void discover_ebda(void)
L
Linus Torvalds 已提交
205
{
206
	/*
L
Linus Torvalds 已提交
207 208 209
	 * there is a real-mode segmented pointer pointing to the 
	 * 4K EBDA area at 0x40E
	 */
210
	ebda_addr = *(unsigned short *)__va(EBDA_ADDR_POINTER);
211 212
	ebda_addr <<= 4;

213
	ebda_size = *(unsigned short *)__va(ebda_addr);
214 215 216 217 218 219 220 221

	/* Round EBDA up to pages */
	if (ebda_size == 0)
		ebda_size = 1;
	ebda_size <<= 10;
	ebda_size = round_up(ebda_size + (ebda_addr & ~PAGE_MASK), PAGE_SIZE);
	if (ebda_size > 64*1024)
		ebda_size = 64*1024;
L
Linus Torvalds 已提交
222 223 224 225
}

void __init setup_arch(char **cmdline_p)
{
226
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
227

L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
 	ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
 	screen_info = SCREEN_INFO;
	edid_info = EDID_INFO;
	saved_video_mode = SAVED_VIDEO_MODE;
	bootloader_type = LOADER_TYPE;

#ifdef CONFIG_BLK_DEV_RAM
	rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
#endif
	setup_memory_region();
	copy_edd();

	if (!MOUNT_ROOT_RDONLY)
		root_mountflags &= ~MS_RDONLY;
	init_mm.start_code = (unsigned long) &_text;
	init_mm.end_code = (unsigned long) &_etext;
	init_mm.end_data = (unsigned long) &_edata;
	init_mm.brk = (unsigned long) &_end;

249 250 251 252
	code_resource.start = virt_to_phys(&_text);
	code_resource.end = virt_to_phys(&_etext)-1;
	data_resource.start = virt_to_phys(&_etext);
	data_resource.end = virt_to_phys(&_edata)-1;
L
Linus Torvalds 已提交
253 254 255

	early_identify_cpu(&boot_cpu_data);

256
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
257 258 259 260 261
	*cmdline_p = command_line;

	parse_early_param();

	finish_e820_parsing();
262

263
	e820_register_active_regions(0, 0, -1UL);
L
Linus Torvalds 已提交
264 265 266 267 268
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
	end_pfn = e820_end_of_ram();
269
	num_physpages = end_pfn;
L
Linus Torvalds 已提交
270 271 272

	check_efer();

273 274
	discover_ebda();

L
Linus Torvalds 已提交
275 276
	init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));

277 278
	dmi_scan_machine();

L
Len Brown 已提交
279
#ifdef CONFIG_ACPI
L
Linus Torvalds 已提交
280 281 282 283 284 285 286
	/*
	 * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
	 * Call this early for SRAT node setup.
	 */
	acpi_boot_table_init();
#endif

287 288 289 290 291
	/* How many end-of-memory variables you have, grandma! */
	max_low_pfn = end_pfn;
	max_pfn = end_pfn;
	high_memory = (void *)__va(end_pfn * PAGE_SIZE - 1) + 1;

292 293 294
	/* Remove active ranges so rediscovery with NUMA-awareness happens */
	remove_all_active_ranges();

L
Linus Torvalds 已提交
295 296 297 298 299 300 301
#ifdef CONFIG_ACPI_NUMA
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
#endif

302
#ifdef CONFIG_NUMA
L
Linus Torvalds 已提交
303 304
	numa_initmem_init(0, end_pfn); 
#else
305
	contig_initmem_init(0, end_pfn);
L
Linus Torvalds 已提交
306 307 308 309 310 311 312
#endif

	/* Reserve direct mapping */
	reserve_bootmem_generic(table_start << PAGE_SHIFT, 
				(table_end - table_start) << PAGE_SHIFT);

	/* reserve kernel */
313 314
	reserve_bootmem_generic(__pa_symbol(&_text),
				__pa_symbol(&_end) - __pa_symbol(&_text));
L
Linus Torvalds 已提交
315 316 317 318 319 320 321 322

	/*
	 * reserve physical page 0 - it's a special BIOS page on many boxes,
	 * enabling clean reboots, SMP operation, laptop functions.
	 */
	reserve_bootmem_generic(0, PAGE_SIZE);

	/* reserve ebda region */
323 324
	if (ebda_addr)
		reserve_bootmem_generic(ebda_addr, ebda_size);
325 326 327 328 329
#ifdef CONFIG_NUMA
	/* reserve nodemap region */
	if (nodemap_addr)
		reserve_bootmem_generic(nodemap_addr, nodemap_size);
#endif
L
Linus Torvalds 已提交
330 331 332

#ifdef CONFIG_SMP
	/* Reserve SMP trampoline */
333
	reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, 2*PAGE_SIZE);
L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
#endif

#ifdef CONFIG_ACPI_SLEEP
       /*
        * Reserve low memory region for sleep support.
        */
       acpi_reserve_bootmem();
#endif
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
#ifdef CONFIG_BLK_DEV_INITRD
	if (LOADER_TYPE && INITRD_START) {
		if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
			reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
350
			initrd_start = INITRD_START + PAGE_OFFSET;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358 359 360 361
			initrd_end = initrd_start+INITRD_SIZE;
		}
		else {
			printk(KERN_ERR "initrd extends beyond end of memory "
			    "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
			    (unsigned long)(INITRD_START + INITRD_SIZE),
			    (unsigned long)(end_pfn << PAGE_SHIFT));
			initrd_start = 0;
		}
	}
#endif
362 363
#ifdef CONFIG_KEXEC
	if (crashk_res.start != crashk_res.end) {
364
		reserve_bootmem_generic(crashk_res.start,
365 366 367
			crashk_res.end - crashk_res.start + 1);
	}
#endif
368

L
Linus Torvalds 已提交
369 370
	paging_init();

371
#ifdef CONFIG_PCI
372
	early_quirks();
373
#endif
L
Linus Torvalds 已提交
374

375 376 377 378 379 380
	/*
	 * set this early, so we dont allocate cpu0
	 * if MADT list doesnt list BSP first
	 * mpparse.c/MP_processor_info() allocates logical cpu numbers.
	 */
	cpu_set(0, cpu_present_map);
L
Len Brown 已提交
381
#ifdef CONFIG_ACPI
L
Linus Torvalds 已提交
382 383 384 385 386 387
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
	acpi_boot_init();
#endif

388 389
	init_cpu_to_node();

L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397
	/*
	 * get boot-time SMP configuration:
	 */
	if (smp_found_config)
		get_smp_config();
	init_apic_mappings();

	/*
A
Andi Kleen 已提交
398 399
	 * We trust e820 completely. No explicit ROM probing in memory.
 	 */
L
Linus Torvalds 已提交
400
	e820_reserve_resources(); 
401
	e820_mark_nosave_regions();
L
Linus Torvalds 已提交
402 403 404 405

	{
	unsigned i;
	/* request I/O space for devices used on all i[345]86 PCs */
A
Andi Kleen 已提交
406
	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
L
Linus Torvalds 已提交
407 408 409
		request_resource(&ioport_resource, &standard_io_resources[i]);
	}

410
	e820_setup_gap();
L
Linus Torvalds 已提交
411 412 413 414 415 416 417 418 419 420

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
}

421
static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
422 423 424
{
	unsigned int *v;

425
	if (c->extended_cpuid_level < 0x80000004)
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433 434 435 436
		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;
	return 1;
}


437
static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
438 439 440
{
	unsigned int n, dummy, eax, ebx, ecx, edx;

441
	n = c->extended_cpuid_level;
L
Linus Torvalds 已提交
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470

	if (n >= 0x80000005) {
		cpuid(0x80000005, &dummy, &ebx, &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);
		c->x86_cache_size=(ecx>>24)+(edx>>24);
		/* On K8 L1 TLB is inclusive, so don't count it */
		c->x86_tlbsize = 0;
	}

	if (n >= 0x80000006) {
		cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
		ecx = cpuid_ecx(0x80000006);
		c->x86_cache_size = ecx >> 16;
		c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);

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

	if (n >= 0x80000007)
		cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power); 
	if (n >= 0x80000008) {
		cpuid(0x80000008, &eax, &dummy, &dummy, &dummy); 
		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
	}
}

471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
#ifdef CONFIG_NUMA
static int nearby_node(int apicid)
{
	int i;
	for (i = apicid - 1; i >= 0; i--) {
		int node = apicid_to_node[i];
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
		int node = apicid_to_node[i];
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	return first_node(node_online_map); /* Shouldn't happen */
}
#endif

489 490 491 492 493 494 495
/*
 * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
 * Assumes number of cores is a power of two.
 */
static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
{
#ifdef CONFIG_SMP
496
	unsigned bits;
497
#ifdef CONFIG_NUMA
498
	int cpu = smp_processor_id();
499
	int node = 0;
500
	unsigned apicid = hard_smp_processor_id();
501
#endif
502
	unsigned ecx = cpuid_ecx(0x80000008);
503

504
	c->x86_max_cores = (ecx & 0xff) + 1;
505

506 507 508 509 510 511 512 513
	/* CPU telling us the core id bits shift? */
	bits = (ecx >> 12) & 0xF;

	/* Otherwise recompute */
	if (bits == 0) {
		while ((1 << bits) < c->x86_max_cores)
			bits++;
	}
514 515

	/* Low order bits define the core id (index of core in socket) */
516
	c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
517
	/* Convert the APIC ID into the socket ID */
518
	c->phys_proc_id = phys_pkg_id(bits);
519 520

#ifdef CONFIG_NUMA
521
  	node = c->phys_proc_id;
522 523 524 525 526 527 528 529 530 531 532 533
 	if (apicid_to_node[apicid] != NUMA_NO_NODE)
 		node = apicid_to_node[apicid];
 	if (!node_online(node)) {
 		/* Two possibilities here:
 		   - The CPU is missing memory and no node was created.
 		   In that case try picking one from a nearby CPU
 		   - The APIC IDs differ from the HyperTransport node IDs
 		   which the K8 northbridge parsing fills in.
 		   Assume they are all increased by a constant offset,
 		   but in the same order as the HT nodeids.
 		   If that doesn't result in a usable node fall back to the
 		   path for the previous case.  */
534
 		int ht_nodeid = apicid - (cpu_data[0].phys_proc_id << bits);
535 536 537 538 539 540 541
 		if (ht_nodeid >= 0 &&
 		    apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
 			node = apicid_to_node[ht_nodeid];
 		/* Pick a nearby node */
 		if (!node_online(node))
 			node = nearby_node(apicid);
 	}
542
	numa_set_node(cpu, node);
543

544
	printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
545 546 547
#endif
#endif
}
L
Linus Torvalds 已提交
548

549
static void __cpuinit init_amd(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
550
{
551
	unsigned level;
L
Linus Torvalds 已提交
552

553 554 555
#ifdef CONFIG_SMP
	unsigned long value;

556 557 558 559 560 561 562 563 564 565 566 567
	/*
	 * Disable TLB flush filter by setting HWCR.FFDIS on K8
	 * bit 6 of msr C001_0015
 	 *
	 * Errata 63 for SH-B3 steppings
	 * Errata 122 for all steppings (F+ have it disabled by default)
	 */
	if (c->x86 == 15) {
		rdmsrl(MSR_K8_HWCR, value);
		value |= 1 << 6;
		wrmsrl(MSR_K8_HWCR, value);
	}
568 569
#endif

L
Linus Torvalds 已提交
570 571 572 573
	/* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
	   3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
	clear_bit(0*32+31, &c->x86_capability);
	
574 575 576 577 578
	/* On C+ stepping K8 rep microcode works well for copy/memset */
	level = cpuid_eax(1);
	if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
		set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);

579 580 581 582
	/* Enable workaround for FXSAVE leak */
	if (c->x86 >= 6)
		set_bit(X86_FEATURE_FXSAVE_LEAK, &c->x86_capability);

583 584
	level = get_model_name(c);
	if (!level) {
L
Linus Torvalds 已提交
585 586 587 588 589 590 591 592 593 594
		switch (c->x86) { 
		case 15:
			/* Should distinguish Models here, but this is only
			   a fallback anyways. */
			strcpy(c->x86_model_id, "Hammer");
			break; 
		} 
	} 
	display_cacheinfo(c);

595 596 597 598
	/* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
	if (c->x86_power & (1<<8))
		set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);

599 600
	/* Multi core CPU? */
	if (c->extended_cpuid_level >= 0x80000008)
601
		amd_detect_cmp(c);
L
Linus Torvalds 已提交
602

603 604
	/* Fix cpuid4 emulation for more */
	num_cache_leaves = 3;
605

606 607
	/* RDTSC can be speculated around */
	clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
608 609 610 611

	/* Family 10 doesn't support C states in MWAIT so don't use it */
	if (c->x86 == 0x10 && !force_mwait)
		clear_bit(X86_FEATURE_MWAIT, &c->x86_capability);
L
Linus Torvalds 已提交
612 613
}

614
static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
615 616 617
{
#ifdef CONFIG_SMP
	u32 	eax, ebx, ecx, edx;
618 619 620 621 622
	int 	index_msb, core_bits;

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


623
	if (!cpu_has(c, X86_FEATURE_HT))
L
Linus Torvalds 已提交
624
		return;
625 626
 	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
		goto out;
L
Linus Torvalds 已提交
627 628

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

L
Linus Torvalds 已提交
630 631
	if (smp_num_siblings == 1) {
		printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
632 633
	} else if (smp_num_siblings > 1 ) {

L
Linus Torvalds 已提交
634 635 636 637 638
		if (smp_num_siblings > NR_CPUS) {
			printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
			smp_num_siblings = 1;
			return;
		}
639 640

		index_msb = get_count_order(smp_num_siblings);
641
		c->phys_proc_id = phys_pkg_id(index_msb);
642

643
		smp_num_siblings = smp_num_siblings / c->x86_max_cores;
644

645 646 647
		index_msb = get_count_order(smp_num_siblings) ;

		core_bits = get_count_order(c->x86_max_cores);
648

649
		c->cpu_core_id = phys_pkg_id(index_msb) &
650
					       ((1 << core_bits) - 1);
L
Linus Torvalds 已提交
651
	}
652 653 654 655 656 657
out:
	if ((c->x86_max_cores * smp_num_siblings) > 1) {
		printk(KERN_INFO  "CPU: Physical Processor ID: %d\n", c->phys_proc_id);
		printk(KERN_INFO  "CPU: Processor Core ID: %d\n", c->cpu_core_id);
	}

L
Linus Torvalds 已提交
658 659 660
#endif
}

661 662 663
/*
 * find out the number of processor cores on the die
 */
664
static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
665
{
666
	unsigned int eax, t;
667 668 669 670

	if (c->cpuid_level < 4)
		return 1;

671
	cpuid_count(4, 0, &eax, &t, &t, &t);
672 673 674 675 676 677 678

	if (eax & 0x1f)
		return ((eax >> 26) + 1);
	else
		return 1;
}

679 680 681
static void srat_detect_node(void)
{
#ifdef CONFIG_NUMA
682
	unsigned node;
683
	int cpu = smp_processor_id();
684
	int apicid = hard_smp_processor_id();
685 686 687

	/* Don't do the funky fallback heuristics the AMD version employs
	   for now. */
688
	node = apicid_to_node[apicid];
689
	if (node == NUMA_NO_NODE)
690
		node = first_node(node_online_map);
691
	numa_set_node(cpu, node);
692

A
Andi Kleen 已提交
693
	printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
694 695 696
#endif
}

697
static void __cpuinit init_intel(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
698 699 700 701 702
{
	/* Cache sizes */
	unsigned n;

	init_intel_cacheinfo(c);
703 704 705 706 707 708 709
	if (c->cpuid_level > 9 ) {
		unsigned eax = cpuid_eax(10);
		/* Check for version and the number of counters */
		if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
			set_bit(X86_FEATURE_ARCH_PERFMON, &c->x86_capability);
	}

710 711 712
	if (cpu_has_ds) {
		unsigned int l1, l2;
		rdmsr(MSR_IA32_MISC_ENABLE, l1, l2);
713 714
		if (!(l1 & (1<<11)))
			set_bit(X86_FEATURE_BTS, c->x86_capability);
715 716 717 718
		if (!(l1 & (1<<12)))
			set_bit(X86_FEATURE_PEBS, c->x86_capability);
	}

719
	n = c->extended_cpuid_level;
L
Linus Torvalds 已提交
720 721 722 723
	if (n >= 0x80000008) {
		unsigned eax = cpuid_eax(0x80000008);
		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
724 725 726 727 728
		/* CPUID workaround for Intel 0F34 CPU */
		if (c->x86_vendor == X86_VENDOR_INTEL &&
		    c->x86 == 0xF && c->x86_model == 0x3 &&
		    c->x86_mask == 0x4)
			c->x86_phys_bits = 36;
L
Linus Torvalds 已提交
729 730 731 732
	}

	if (c->x86 == 15)
		c->x86_cache_alignment = c->x86_clflush_size * 2;
733 734
	if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
	    (c->x86 == 0x6 && c->x86_model >= 0x0e))
735
		set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
736 737
	if (c->x86 == 6)
		set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
738 739 740 741
	if (c->x86 == 15)
		set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
	else
		clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
742
 	c->x86_max_cores = intel_num_cpu_cores(c);
743 744

	srat_detect_node();
L
Linus Torvalds 已提交
745 746
}

747
static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
{
	char *v = c->x86_vendor_id;

	if (!strcmp(v, "AuthenticAMD"))
		c->x86_vendor = X86_VENDOR_AMD;
	else if (!strcmp(v, "GenuineIntel"))
		c->x86_vendor = X86_VENDOR_INTEL;
	else
		c->x86_vendor = X86_VENDOR_UNKNOWN;
}

struct cpu_model_info {
	int vendor;
	int family;
	char *model_names[16];
};

/* Do some early cpuid on the boot CPU to get some parameter that are
   needed before check_bugs. Everything advanced is in identify_cpu
   below. */
768
void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
769 770 771 772 773 774 775 776 777 778 779
{
	u32 tfms;

	c->loops_per_jiffy = loops_per_jiffy;
	c->x86_cache_size = -1;
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	c->x86_model = c->x86_mask = 0;	/* So far unknown... */
	c->x86_vendor_id[0] = '\0'; /* Unset */
	c->x86_model_id[0] = '\0';  /* Unset */
	c->x86_clflush_size = 64;
	c->x86_cache_alignment = c->x86_clflush_size;
780
	c->x86_max_cores = 1;
781
	c->extended_cpuid_level = 0;
L
Linus Torvalds 已提交
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

	/* Get vendor name */
	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]);
		
	get_cpu_vendor(c);

	/* Initialize the standard set of capabilities */
	/* Note that the vendor-specific code below might override */

	/* Intel-defined flags: level 0x00000001 */
	if (c->cpuid_level >= 0x00000001) {
		__u32 misc;
		cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
		      &c->x86_capability[0]);
		c->x86 = (tfms >> 8) & 0xf;
		c->x86_model = (tfms >> 4) & 0xf;
		c->x86_mask = tfms & 0xf;
803
		if (c->x86 == 0xf)
L
Linus Torvalds 已提交
804
			c->x86 += (tfms >> 20) & 0xff;
805
		if (c->x86 >= 0x6)
L
Linus Torvalds 已提交
806 807 808 809 810 811 812
			c->x86_model += ((tfms >> 16) & 0xF) << 4;
		if (c->x86_capability[0] & (1<<19)) 
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
	} else {
		/* Have CPUID level 0 only - unheard of */
		c->x86 = 4;
	}
813 814

#ifdef CONFIG_SMP
815
	c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
816
#endif
L
Linus Torvalds 已提交
817 818 819 820 821
}

/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
822
void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830
{
	int i;
	u32 xlvl;

	early_identify_cpu(c);

	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
831
	c->extended_cpuid_level = xlvl;
L
Linus Torvalds 已提交
832 833 834
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
835
			c->x86_capability[6] = cpuid_ecx(0x80000001);
L
Linus Torvalds 已提交
836 837 838 839 840 841 842 843 844 845 846 847 848
		}
		if (xlvl >= 0x80000004)
			get_model_name(c); /* Default name */
	}

	/* Transmeta-defined flags: level 0x80860001 */
	xlvl = cpuid_eax(0x80860000);
	if ((xlvl & 0xffff0000) == 0x80860000) {
		/* Don't set x86_cpuid_level here for now to not confuse. */
		if (xlvl >= 0x80860001)
			c->x86_capability[2] = cpuid_edx(0x80860001);
	}

849 850
	c->apicid = phys_pkg_id(0);

L
Linus Torvalds 已提交
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
	/*
	 * 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!
	 */
	switch (c->x86_vendor) {
	case X86_VENDOR_AMD:
		init_amd(c);
		break;

	case X86_VENDOR_INTEL:
		init_intel(c);
		break;

	case X86_VENDOR_UNKNOWN:
	default:
		display_cacheinfo(c);
		break;
	}

	select_idle_routine(c);
	detect_ht(c); 

	/*
	 * 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.
	 */
	if (c != &boot_cpu_data) {
		/* AND the already accumulated flags with these */
		for (i = 0 ; i < NCAPINTS ; i++)
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
	}

#ifdef CONFIG_X86_MCE
	mcheck_init(c);
#endif
894
	if (c != &boot_cpu_data)
S
Shaohua Li 已提交
895
		mtrr_ap_init();
L
Linus Torvalds 已提交
896
#ifdef CONFIG_NUMA
897
	numa_add_cpu(smp_processor_id());
L
Linus Torvalds 已提交
898 899 900 901
#endif
}
 

902
void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
{
	if (c->x86_model_id[0])
		printk("%s", c->x86_model_id);

	if (c->x86_mask || c->cpuid_level >= 0) 
		printk(" stepping %02x\n", c->x86_mask);
	else
		printk("\n");
}

/*
 *	Get CPU information for use by the procfs.
 */

static int show_cpuinfo(struct seq_file *m, void *v)
{
	struct cpuinfo_x86 *c = v;

	/* 
	 * These flag bits must match the definitions in <asm/cpufeature.h>.
	 * NULL means this bit is undefined or reserved; either way it doesn't
	 * have meaning as far as Linux is concerned.  Note that it's important
	 * to realize there is a difference between this table and CPUID -- if
	 * applications want to get the raw CPUID data, they should access
	 * /dev/cpu/<cpu_nr>/cpuid instead.
	 */
	static char *x86_cap_flags[] = {
		/* Intel-defined */
	        "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
	        "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
	        "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
934
	        "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
L
Linus Torvalds 已提交
935 936

		/* AMD-defined */
937
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
L
Linus Torvalds 已提交
938 939
		NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
940 941
		NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
		"3dnowext", "3dnow",
L
Linus Torvalds 已提交
942 943 944 945 946 947 948 949

		/* Transmeta-defined */
		"recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

		/* Other (Linux-defined) */
950 951 952 953 954
		"cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
		NULL, NULL, NULL, NULL,
		"constant_tsc", "up", NULL, "arch_perfmon",
		"pebs", "bts", NULL, "sync_rdtsc",
		"rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
L
Linus Torvalds 已提交
955 956 957
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

		/* Intel-defined (#2) */
958
		"pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
959
		"tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
960
		NULL, NULL, "dca", NULL, NULL, NULL, NULL, "popcnt",
L
Linus Torvalds 已提交
961 962
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

963 964
		/* VIA/Cyrix/Centaur-defined */
		NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
965
		"ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
966 967 968
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

L
Linus Torvalds 已提交
969
		/* AMD-defined (#2) */
970 971 972 973
		"lahf_lm", "cmp_legacy", "svm", "extapic", "cr8_legacy",
		"altmovcr8", "abm", "sse4a",
		"misalignsse", "3dnowprefetch",
		"osvw", "ibs", NULL, NULL, NULL, NULL,
L
Linus Torvalds 已提交
974
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
975
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
L
Linus Torvalds 已提交
976 977 978 979 980 981 982
	};
	static char *x86_power_flags[] = { 
		"ts",	/* temperature sensor */
		"fid",  /* frequency id control */
		"vid",  /* voltage id control */
		"ttp",  /* thermal trip */
		"tm",
983
		"stc",
984 985
		"100mhzsteps",
		"hwpstate",
986 987
		"",	/* tsc invariant mapped to constant_tsc */
		/* nothing */
L
Linus Torvalds 已提交
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	};


#ifdef CONFIG_SMP
	if (!cpu_online(c-cpu_data))
		return 0;
#endif

	seq_printf(m,"processor\t: %u\n"
		     "vendor_id\t: %s\n"
		     "cpu family\t: %d\n"
		     "model\t\t: %d\n"
		     "model name\t: %s\n",
		     (unsigned)(c-cpu_data),
		     c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
		     c->x86,
		     (int)c->x86_model,
		     c->x86_model_id[0] ? c->x86_model_id : "unknown");
	
	if (c->x86_mask || c->cpuid_level >= 0)
		seq_printf(m, "stepping\t: %d\n", c->x86_mask);
	else
		seq_printf(m, "stepping\t: unknown\n");
	
	if (cpu_has(c,X86_FEATURE_TSC)) {
1013 1014 1015
		unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data));
		if (!freq)
			freq = cpu_khz;
L
Linus Torvalds 已提交
1016
		seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1017
			     freq / 1000, (freq % 1000));
L
Linus Torvalds 已提交
1018 1019 1020 1021 1022 1023 1024
	}

	/* Cache size */
	if (c->x86_cache_size >= 0) 
		seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
	
#ifdef CONFIG_SMP
1025
	if (smp_num_siblings * c->x86_max_cores > 1) {
1026
		int cpu = c - cpu_data;
1027
		seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1028
		seq_printf(m, "siblings\t: %d\n", cpus_weight(cpu_core_map[cpu]));
1029
		seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1030
		seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1031
	}
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
#endif	

	seq_printf(m,
	        "fpu\t\t: yes\n"
	        "fpu_exception\t: yes\n"
	        "cpuid level\t: %d\n"
	        "wp\t\t: yes\n"
	        "flags\t\t:",
		   c->cpuid_level);

	{ 
		int i; 
		for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1045
			if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
				seq_printf(m, " %s", x86_cap_flags[i]);
	}
		
	seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
		   c->loops_per_jiffy/(500000/HZ),
		   (c->loops_per_jiffy/(5000/HZ)) % 100);

	if (c->x86_tlbsize > 0) 
		seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
	seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
	seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);

	seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n", 
		   c->x86_phys_bits, c->x86_virt_bits);

	seq_printf(m, "power management:");
	{
		unsigned i;
		for (i = 0; i < 32; i++) 
			if (c->x86_power & (1 << i)) {
1066 1067 1068 1069 1070
				if (i < ARRAY_SIZE(x86_power_flags) &&
					x86_power_flags[i])
					seq_printf(m, "%s%s",
						x86_power_flags[i][0]?" ":"",
						x86_power_flags[i]);
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075
				else
					seq_printf(m, " [%d]", i);
			}
	}

1076
	seq_printf(m, "\n\n");
L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	return *pos < NR_CPUS ? cpu_data + *pos : NULL;
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
	++*pos;
	return c_start(m, pos);
}

static void c_stop(struct seq_file *m, void *v)
{
}

struct seq_operations cpuinfo_op = {
	.start =c_start,
	.next =	c_next,
	.stop =	c_stop,
	.show =	show_cpuinfo,
};