setup_64.c 31.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 *  Copyright (C) 1995  Linus Torvalds
 */

/*
 * 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>
19
#include <linux/screen_info.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22 23 24 25 26 27 28 29
#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>
30
#include <linux/crash_dump.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32
#include <linux/root_dev.h>
#include <linux/pci.h>
33
#include <linux/efi.h>
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36
#include <linux/acpi.h>
#include <linux/kallsyms.h>
#include <linux/edd.h>
37
#include <linux/mmzone.h>
38
#include <linux/kexec.h>
39
#include <linux/cpufreq.h>
40
#include <linux/dmi.h>
41
#include <linux/dma-mapping.h>
42
#include <linux/ctype.h>
43
#include <linux/uaccess.h>
44

Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
#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/proto.h>
#include <asm/setup.h>
#include <asm/mach_apic.h>
#include <asm/numa.h>
61
#include <asm/sections.h>
62
#include <asm/dmi.h>
63
#include <asm/cacheflush.h>
64
#include <asm/mce.h>
65
#include <asm/ds.h>
Linus Torvalds's avatar
Linus Torvalds committed
66

67 68 69 70 71 72
#ifdef CONFIG_PARAVIRT
#include <asm/paravirt.h>
#else
#define ARCH_SETUP
#endif

Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76
/*
 * Machine setup..
 */

77
struct cpuinfo_x86 boot_cpu_data __read_mostly;
78
EXPORT_SYMBOL(boot_cpu_data);
Linus Torvalds's avatar
Linus Torvalds committed
79 80 81 82 83 84 85 86

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;

87 88
int force_mwait __cpuinitdata;

89
/*
90 91 92 93 94
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98
/*
 * Setup options
 */
struct screen_info screen_info;
99
EXPORT_SYMBOL(screen_info);
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103 104 105
struct sys_desc_table_struct {
	unsigned short length;
	unsigned char table[0];
};

struct edid_info edid_info;
106
EXPORT_SYMBOL_GPL(edid_info);
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109

extern int root_mountflags;

110
char __initdata command_line[COMMAND_LINE_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

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)

135
static struct resource data_resource = {
Linus Torvalds's avatar
Linus Torvalds committed
136 137 138 139 140
	.name = "Kernel data",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
};
141
static struct resource code_resource = {
Linus Torvalds's avatar
Linus Torvalds committed
142 143 144 145 146
	.name = "Kernel code",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
};
147
static struct resource bss_resource = {
148 149 150 151 152
	.name = "Kernel bss",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
};
Linus Torvalds's avatar
Linus Torvalds committed
153

154 155
static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c);

156 157 158 159 160 161
#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)
162
{
163 164 165 166 167
	char *end;
	if (!arg)
		return -EINVAL;
	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
168
}
169
early_param("elfcorehdr", setup_elfcorehdr);
170 171
#endif

172
#ifndef CONFIG_NUMA
173 174
static void __init
contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
Linus Torvalds's avatar
Linus Torvalds committed
175
{
176 177 178 179 180
	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)
181
		panic("Cannot find bootmem map of size %ld\n", bootmap_size);
182
	bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
183 184
	e820_register_active_regions(0, start_pfn, end_pfn);
	free_bootmem_with_active_regions(0, end_pfn);
185
	reserve_bootmem(bootmap, bootmap_size);
186
}
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200
#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)
{
201 202 203 204 205
     memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	    sizeof(edd.mbr_signature));
     memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
     edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
     edd.edd_info_nr = boot_params.eddbuf_entries;
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209 210 211 212
}
#else
static inline void copy_edd(void)
{
}
#endif

213 214 215 216 217 218 219
#ifdef CONFIG_KEXEC
static void __init reserve_crashkernel(void)
{
	unsigned long long free_mem;
	unsigned long long crash_size, crash_base;
	int ret;

220 221
	free_mem =
		((unsigned long long)max_low_pfn - min_low_pfn) << PAGE_SHIFT;
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244

	ret = parse_crashkernel(boot_command_line, free_mem,
			&crash_size, &crash_base);
	if (ret == 0 && crash_size) {
		if (crash_base > 0) {
			printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
					"for crashkernel (System RAM: %ldMB)\n",
					(unsigned long)(crash_size >> 20),
					(unsigned long)(crash_base >> 20),
					(unsigned long)(free_mem >> 20));
			crashk_res.start = crash_base;
			crashk_res.end   = crash_base + crash_size - 1;
			reserve_bootmem(crash_base, crash_size);
		} else
			printk(KERN_INFO "crashkernel reservation failed - "
					"you have to specify a base address\n");
	}
}
#else
static inline void __init reserve_crashkernel(void)
{}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
245
#define EBDA_ADDR_POINTER 0x40E
246 247 248 249 250

unsigned __initdata ebda_addr;
unsigned __initdata ebda_size;

static void discover_ebda(void)
Linus Torvalds's avatar
Linus Torvalds committed
251
{
252
	/*
253
	 * there is a real-mode segmented pointer pointing to the
Linus Torvalds's avatar
Linus Torvalds committed
254 255
	 * 4K EBDA area at 0x40E
	 */
256
	ebda_addr = *(unsigned short *)__va(EBDA_ADDR_POINTER);
257 258 259 260 261 262 263 264 265 266
	/*
	 * There can be some situations, like paravirtualized guests,
	 * in which there is no available ebda information. In such
	 * case, just skip it
	 */
	if (!ebda_addr) {
		ebda_size = 0;
		return;
	}

267 268
	ebda_addr <<= 4;

269
	ebda_size = *(unsigned short *)__va(ebda_addr);
270 271 272 273 274 275 276 277

	/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
278 279
}

280 281 282 283 284 285
/* Overridden in paravirt.c if CONFIG_PARAVIRT */
void __attribute__((weak)) memory_setup(void)
{
       machine_specific_memory_setup();
}

Linus Torvalds's avatar
Linus Torvalds committed
286 287
void __init setup_arch(char **cmdline_p)
{
288 289
	unsigned i;

290
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
291

292 293 294 295 296
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
	saved_video_mode = boot_params.hdr.vid_mode;
	bootloader_type = boot_params.hdr.type_of_loader;
Linus Torvalds's avatar
Linus Torvalds committed
297 298

#ifdef CONFIG_BLK_DEV_RAM
299 300 301
	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
Linus Torvalds's avatar
Linus Torvalds committed
302
#endif
303 304 305 306 307
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
		     "EL64", 4))
		efi_enabled = 1;
#endif
308 309 310 311

	ARCH_SETUP

	memory_setup();
Linus Torvalds's avatar
Linus Torvalds committed
312 313
	copy_edd();

314
	if (!boot_params.hdr.root_flags)
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318 319 320
		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;

321 322 323 324
	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;
325 326
	bss_resource.start = virt_to_phys(&__bss_start);
	bss_resource.end = virt_to_phys(&__bss_stop)-1;
Linus Torvalds's avatar
Linus Torvalds committed
327 328 329

	early_identify_cpu(&boot_cpu_data);

330
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
331 332 333 334 335
	*cmdline_p = command_line;

	parse_early_param();

	finish_e820_parsing();
336

337
	e820_register_active_regions(0, 0, -1UL);
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341 342
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
	end_pfn = e820_end_of_ram();
343
	num_physpages = end_pfn;
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346

	check_efer();

347 348
	discover_ebda();

Linus Torvalds's avatar
Linus Torvalds committed
349
	init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
350 351
	if (efi_enabled)
		efi_init();
Linus Torvalds's avatar
Linus Torvalds committed
352

353 354
	dmi_scan_machine();

355 356
	io_delay_init();

357 358 359 360 361
#ifdef CONFIG_SMP
	/* setup to use the static apicid table during kernel startup */
	x86_cpu_to_apicid_ptr = (void *)&x86_cpu_to_apicid_init;
#endif

Len Brown's avatar
Len Brown committed
362
#ifdef CONFIG_ACPI
Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366 367 368 369
	/*
	 * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
	 * Call this early for SRAT node setup.
	 */
	acpi_boot_table_init();
#endif

370 371 372 373 374
	/* 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;

375 376 377
	/* Remove active ranges so rediscovery with NUMA-awareness happens */
	remove_all_active_ranges();

Linus Torvalds's avatar
Linus Torvalds committed
378 379 380 381 382 383 384
#ifdef CONFIG_ACPI_NUMA
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
#endif

385
#ifdef CONFIG_NUMA
386
	numa_initmem_init(0, end_pfn);
Linus Torvalds's avatar
Linus Torvalds committed
387
#else
388
	contig_initmem_init(0, end_pfn);
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391
#endif

	/* Reserve direct mapping */
392
	reserve_bootmem_generic(table_start << PAGE_SHIFT,
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395
				(table_end - table_start) << PAGE_SHIFT);

	/* reserve kernel */
396 397
	reserve_bootmem_generic(__pa_symbol(&_text),
				__pa_symbol(&_end) - __pa_symbol(&_text));
Linus Torvalds's avatar
Linus Torvalds committed
398 399 400 401 402 403 404 405

	/*
	 * 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 */
406 407
	if (ebda_addr)
		reserve_bootmem_generic(ebda_addr, ebda_size);
408 409 410 411 412
#ifdef CONFIG_NUMA
	/* reserve nodemap region */
	if (nodemap_addr)
		reserve_bootmem_generic(nodemap_addr, nodemap_size);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415

#ifdef CONFIG_SMP
	/* Reserve SMP trampoline */
416
	reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, 2*PAGE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
417 418
#endif

Len Brown's avatar
Len Brown committed
419
#ifdef CONFIG_ACPI_SLEEP
Linus Torvalds's avatar
Linus Torvalds committed
420
	/*
421
	 * Reserve low memory region for sleep support.
Linus Torvalds's avatar
Linus Torvalds committed
422
	 */
423 424
       acpi_reserve_bootmem();
#endif
425 426 427 428 429 430

	if (efi_enabled) {
		efi_map_memmap();
		efi_reserve_bootmem();
	}

431 432 433
       /*
	* Find and reserve possible boot-time SMP configuration:
	*/
Linus Torvalds's avatar
Linus Torvalds committed
434 435
	find_smp_config();
#ifdef CONFIG_BLK_DEV_INITRD
436 437 438 439 440 441 442 443 444 445 446
	if (boot_params.hdr.type_of_loader && boot_params.hdr.ramdisk_image) {
		unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
		unsigned long ramdisk_size  = boot_params.hdr.ramdisk_size;
		unsigned long ramdisk_end   = ramdisk_image + ramdisk_size;
		unsigned long end_of_mem    = end_pfn << PAGE_SHIFT;

		if (ramdisk_end <= end_of_mem) {
			reserve_bootmem_generic(ramdisk_image, ramdisk_size);
			initrd_start = ramdisk_image + PAGE_OFFSET;
			initrd_end = initrd_start+ramdisk_size;
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
447
			printk(KERN_ERR "initrd extends beyond end of memory "
448 449
			       "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
			       ramdisk_end, end_of_mem);
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453
			initrd_start = 0;
		}
	}
#endif
454
	reserve_crashkernel();
Linus Torvalds's avatar
Linus Torvalds committed
455 456
	paging_init();

457
	early_quirks();
Linus Torvalds's avatar
Linus Torvalds committed
458

459 460 461 462 463 464
	/*
	 * 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);
Len Brown's avatar
Len Brown committed
465
#ifdef CONFIG_ACPI
Linus Torvalds's avatar
Linus Torvalds committed
466 467 468 469 470 471
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
	acpi_boot_init();
#endif

472 473
	init_cpu_to_node();

Linus Torvalds's avatar
Linus Torvalds committed
474 475 476 477 478 479
	/*
	 * get boot-time SMP configuration:
	 */
	if (smp_found_config)
		get_smp_config();
	init_apic_mappings();
480
	ioapic_init_mappings();
Linus Torvalds's avatar
Linus Torvalds committed
481 482

	/*
483
	 * We trust e820 completely. No explicit ROM probing in memory.
484
	 */
485
	e820_reserve_resources(&code_resource, &data_resource, &bss_resource);
486
	e820_mark_nosave_regions();
Linus Torvalds's avatar
Linus Torvalds committed
487 488

	/* request I/O space for devices used on all i[345]86 PCs */
489
	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
Linus Torvalds's avatar
Linus Torvalds committed
490 491
		request_resource(&ioport_resource, &standard_io_resources[i]);

492
	e820_setup_gap();
Linus Torvalds's avatar
Linus Torvalds committed
493 494 495

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
496 497
	if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
		conswitchp = &vga_con;
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501 502 503
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
}

504
static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
505 506 507
{
	unsigned int *v;

508
	if (c->extended_cpuid_level < 0x80000004)
Linus Torvalds's avatar
Linus Torvalds committed
509 510 511 512 513 514 515 516 517 518 519
		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;
}


520
static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523
{
	unsigned int n, dummy, eax, ebx, ecx, edx;

524
	n = c->extended_cpuid_level;
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527

	if (n >= 0x80000005) {
		cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
528 529 530 531
		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);
Linus Torvalds's avatar
Linus Torvalds committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
		/* 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)
547
		cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
Linus Torvalds's avatar
Linus Torvalds committed
548
	if (n >= 0x80000008) {
549
		cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
Linus Torvalds's avatar
Linus Torvalds committed
550 551 552 553 554
		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
	}
}

555 556 557
#ifdef CONFIG_NUMA
static int nearby_node(int apicid)
{
558 559
	int i, node;

560
	for (i = apicid - 1; i >= 0; i--) {
561
		node = apicid_to_node[i];
562 563 564 565
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
566
		node = apicid_to_node[i];
567 568 569 570 571 572 573
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	return first_node(node_online_map); /* Shouldn't happen */
}
#endif

574 575 576 577 578 579 580
/*
 * 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
581
	unsigned bits;
582
#ifdef CONFIG_NUMA
583
	int cpu = smp_processor_id();
584
	int node = 0;
585
	unsigned apicid = hard_smp_processor_id();
586
#endif
587
	bits = c->x86_coreid_bits;
588 589

	/* Low order bits define the core id (index of core in socket) */
590
	c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
591
	/* Convert the APIC ID into the socket ID */
592
	c->phys_proc_id = phys_pkg_id(bits);
593 594

#ifdef CONFIG_NUMA
595 596 597 598 599 600 601 602 603 604 605 606 607 608
	node = c->phys_proc_id;
	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.  */

609
		int ht_nodeid = apicid - (cpu_data(0).phys_proc_id << bits);
610 611 612 613 614 615 616 617

		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);
	}
618
	numa_set_node(cpu, node);
619

620
	printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
621 622 623
#endif
#endif
}
Linus Torvalds's avatar
Linus Torvalds committed
624

625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
static void __cpuinit early_init_amd(struct cpuinfo_x86 *c)
{
#ifdef CONFIG_SMP
	unsigned bits, ecx;

	/* Multi core CPU? */
	if (c->extended_cpuid_level < 0x80000008)
		return;

	ecx = cpuid_ecx(0x80000008);

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

	/* 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++;
	}

	c->x86_coreid_bits = bits;

#endif
}

652 653 654 655 656 657 658 659 660 661 662 663
#define ENABLE_C1E_MASK		0x18000000
#define CPUID_PROCESSOR_SIGNATURE	1
#define CPUID_XFAM		0x0ff00000
#define CPUID_XFAM_K8		0x00000000
#define CPUID_XFAM_10H		0x00100000
#define CPUID_XFAM_11H		0x00200000
#define CPUID_XMOD		0x000f0000
#define CPUID_XMOD_REV_F	0x00040000

/* AMD systems with C1E don't have a working lAPIC timer. Check for that. */
static __cpuinit int amd_apic_timer_broken(void)
{
664 665
	u32 lo, hi, eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);

666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
	switch (eax & CPUID_XFAM) {
	case CPUID_XFAM_K8:
		if ((eax & CPUID_XMOD) < CPUID_XMOD_REV_F)
			break;
	case CPUID_XFAM_10H:
	case CPUID_XFAM_11H:
		rdmsr(MSR_K8_ENABLE_C1E, lo, hi);
		if (lo & ENABLE_C1E_MASK)
			return 1;
		break;
	default:
		/* err on the side of caution */
		return 1;
	}
	return 0;
}

683
static void __cpuinit init_amd(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
684
{
685
	unsigned level;
Linus Torvalds's avatar
Linus Torvalds committed
686

687 688 689
#ifdef CONFIG_SMP
	unsigned long value;

690 691 692
	/*
	 * Disable TLB flush filter by setting HWCR.FFDIS on K8
	 * bit 6 of msr C001_0015
693
	 *
694 695 696 697 698 699 700 701
	 * 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);
	}
702 703
#endif

Linus Torvalds's avatar
Linus Torvalds committed
704 705
	/* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
	   3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
706
	clear_bit(0*32+31, (unsigned long *)&c->x86_capability);
707

708 709
	/* On C+ stepping K8 rep microcode works well for copy/memset */
	level = cpuid_eax(1);
710 711
	if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) ||
			     level >= 0x0f58))
712
		set_cpu_cap(c, X86_FEATURE_REP_GOOD);
713
	if (c->x86 == 0x10 || c->x86 == 0x11)
714
		set_cpu_cap(c, X86_FEATURE_REP_GOOD);
715

716 717
	/* Enable workaround for FXSAVE leak */
	if (c->x86 >= 6)
718
		set_cpu_cap(c, X86_FEATURE_FXSAVE_LEAK);
719

720 721
	level = get_model_name(c);
	if (!level) {
722
		switch (c->x86) {
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725 726
		case 15:
			/* Should distinguish Models here, but this is only
			   a fallback anyways. */
			strcpy(c->x86_model_id, "Hammer");
727 728 729
			break;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
730 731
	display_cacheinfo(c);

732 733
	/* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
	if (c->x86_power & (1<<8))
734
		set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC);
735

736 737
	/* Multi core CPU? */
	if (c->extended_cpuid_level >= 0x80000008)
738
		amd_detect_cmp(c);
Linus Torvalds's avatar
Linus Torvalds committed
739

740 741 742 743 744
	if (c->extended_cpuid_level >= 0x80000006 &&
		(cpuid_edx(0x80000006) & 0xf000))
		num_cache_leaves = 4;
	else
		num_cache_leaves = 3;
745

746
	if (c->x86 == 0xf || c->x86 == 0x10 || c->x86 == 0x11)
747
		set_cpu_cap(c, X86_FEATURE_K8);
748

749 750
	/* MFENCE stops RDTSC speculation */
	set_cpu_cap(c, X86_FEATURE_MFENCE_RDTSC);
751 752 753

	/* Family 10 doesn't support C states in MWAIT so don't use it */
	if (c->x86 == 0x10 && !force_mwait)
754
		clear_cpu_cap(c, X86_FEATURE_MWAIT);
755 756 757

	if (amd_apic_timer_broken())
		disable_apic_timer = 1;
Linus Torvalds's avatar
Linus Torvalds committed
758 759
}

760
void __cpuinit detect_ht(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
761 762
{
#ifdef CONFIG_SMP
763 764
	u32 eax, ebx, ecx, edx;
	int index_msb, core_bits;
765 766 767 768

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


769
	if (!cpu_has(c, X86_FEATURE_HT))
Linus Torvalds's avatar
Linus Torvalds committed
770
		return;
771
	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
772
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
773 774

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

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

Linus Torvalds's avatar
Linus Torvalds committed
780
		if (smp_num_siblings > NR_CPUS) {
781 782
			printk(KERN_WARNING "CPU: Unsupported number of "
			       "siblings %d", smp_num_siblings);
Linus Torvalds's avatar
Linus Torvalds committed
783 784 785
			smp_num_siblings = 1;
			return;
		}
786 787

		index_msb = get_count_order(smp_num_siblings);
788
		c->phys_proc_id = phys_pkg_id(index_msb);
789

790
		smp_num_siblings = smp_num_siblings / c->x86_max_cores;
791

792
		index_msb = get_count_order(smp_num_siblings);
793 794

		core_bits = get_count_order(c->x86_max_cores);
795

796
		c->cpu_core_id = phys_pkg_id(index_msb) &
797
					       ((1 << core_bits) - 1);
Linus Torvalds's avatar
Linus Torvalds committed
798
	}
799 800
out:
	if ((c->x86_max_cores * smp_num_siblings) > 1) {
801 802 803 804
		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);
805 806
	}

Linus Torvalds's avatar
Linus Torvalds committed
807 808 809
#endif
}

810 811 812
/*
 * find out the number of processor cores on the die
 */
813
static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
814
{
815
	unsigned int eax, t;
816 817 818 819

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

820
	cpuid_count(4, 0, &eax, &t, &t, &t);
821 822 823 824 825 826 827

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

828 829 830
static void srat_detect_node(void)
{
#ifdef CONFIG_NUMA
831
	unsigned node;
832
	int cpu = smp_processor_id();
833
	int apicid = hard_smp_processor_id();
834 835 836

	/* Don't do the funky fallback heuristics the AMD version employs
	   for now. */
837
	node = apicid_to_node[apicid];
838
	if (node == NUMA_NO_NODE)
839
		node = first_node(node_online_map);
840
	numa_set_node(cpu, node);
841

842
	printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
843 844 845
#endif
}

846
static void __cpuinit init_intel(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
847 848 849 850 851
{
	/* Cache sizes */
	unsigned n;

	init_intel_cacheinfo(c);
852
	if (c->cpuid_level > 9) {
853 854 855
		unsigned eax = cpuid_eax(10);
		/* Check for version and the number of counters */
		if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
856
			set_cpu_cap(c, X86_FEATURE_ARCH_PERFMON);
857 858
	}

859 860 861
	if (cpu_has_ds) {
		unsigned int l1, l2;
		rdmsr(MSR_IA32_MISC_ENABLE, l1, l2);
862
		if (!(l1 & (1<<11)))
863
			set_cpu_cap(c, X86_FEATURE_BTS);
864
		if (!(l1 & (1<<12)))
865
			set_cpu_cap(c, X86_FEATURE_PEBS);
866 867
	}

868 869 870 871

	if (cpu_has_bts)
		ds_init_intel(c);

872
	n = c->extended_cpuid_level;
Linus Torvalds's avatar
Linus Torvalds committed
873 874 875 876
	if (n >= 0x80000008) {
		unsigned eax = cpuid_eax(0x80000008);
		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
877 878 879 880 881
		/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884 885
	}

	if (c->x86 == 15)
		c->x86_cache_alignment = c->x86_clflush_size * 2;
886 887
	if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
	    (c->x86 == 0x6 && c->x86_model >= 0x0e))
888
		set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC);
889
	if (c->x86 == 6)
890
		set_cpu_cap(c, X86_FEATURE_REP_GOOD);
891
	if (c->x86 == 15)
892
		set_cpu_cap(c, X86_FEATURE_SYNC_RDTSC);
893
	else
894
		clear_cpu_cap(c, X86_FEATURE_SYNC_RDTSC);
895
	c->x86_max_cores = intel_num_cpu_cores(c);
896 897

	srat_detect_node();
Linus Torvalds's avatar
Linus Torvalds committed
898 899
}

900
static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
{
	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. */
921
static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
922
{
923
	u32 tfms, xlvl;
Linus Torvalds's avatar
Linus Torvalds committed
924 925 926 927 928 929 930 931 932

	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;
933
	c->x86_max_cores = 1;
934
	c->x86_coreid_bits = 0;
935
	c->extended_cpuid_level = 0;
Linus Torvalds's avatar
Linus Torvalds committed
936 937 938 939 940 941 942
	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]);
943

Linus Torvalds's avatar
Linus Torvalds committed
944 945 946 947 948 949 950 951 952 953 954 955 956
	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;
957
		if (c->x86 == 0xf)
Linus Torvalds's avatar
Linus Torvalds committed
958
			c->x86 += (tfms >> 20) & 0xff;
959
		if (c->x86 >= 0x6)
Linus Torvalds's avatar
Linus Torvalds committed
960
			c->x86_model += ((tfms >> 16) & 0xF) << 4;
961
		if (c->x86_capability[0] & (1<<19))
Linus Torvalds's avatar
Linus Torvalds committed
962 963 964 965 966
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
	} else {
		/* Have CPUID level 0 only - unheard of */
		c->x86 = 4;
	}
967 968

#ifdef CONFIG_SMP
969
	c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
970
#endif
Linus Torvalds's avatar
Linus Torvalds committed
971 972
	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
973
	c->extended_cpuid_level = xlvl;
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
977
			c->x86_capability[6] = cpuid_ecx(0x80000001);
Linus Torvalds's avatar
Linus Torvalds committed
978 979 980 981 982 983 984 985 986 987 988 989 990
		}
		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);
	}

991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
	switch (c->x86_vendor) {
	case X86_VENDOR_AMD:
		early_init_amd(c);
		break;
	}

}

/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
{
	int i;

	early_identify_cpu(c);

1008 1009
	init_scattered_cpuid_features(c);

1010 1011
	c->apicid = phys_pkg_id(0);

Linus Torvalds's avatar
Linus Torvalds committed
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
	/*
	 * 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);
1038
	detect_ht(c);
Linus Torvalds's avatar
Linus Torvalds committed
1039 1040 1041 1042 1043 1044 1045 1046 1047

	/*
	 * 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 */
1048
		for (i = 0; i < NCAPINTS; i++)
Linus Torvalds's avatar
Linus Torvalds committed
1049 1050 1051 1052 1053 1054
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
	}

#ifdef CONFIG_X86_MCE
	mcheck_init(c);
#endif
1055
	if (c != &boot_cpu_data)
1056
		mtrr_ap_init();
Linus Torvalds's avatar
Linus Torvalds committed
1057
#ifdef CONFIG_NUMA
1058
	numa_add_cpu(smp_processor_id());
Linus Torvalds's avatar
Linus Torvalds committed
1059 1060 1061
#endif
}

1062
void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
1063 1064
{
	if (c->x86_model_id[0])
1065
		printk(KERN_INFO "%s", c->x86_model_id);
Linus Torvalds's avatar
Linus Torvalds committed
1066

1067 1068
	if (c->x86_mask || c->cpuid_level >= 0)
		printk(KERN_CONT " stepping %02x\n", c->x86_mask);
Linus Torvalds's avatar
Linus Torvalds committed
1069
	else
1070
		printk(KERN_CONT "\n");
Linus Torvalds's avatar
Linus Torvalds committed
1071 1072 1073 1074 1075 1076 1077 1078 1079
}

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

static int show_cpuinfo(struct seq_file *m, void *v)
{
	struct cpuinfo_x86 *c = v;
1080
	int cpu = 0, i;
Linus Torvalds's avatar
Linus Torvalds committed
1081

1082
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1083 1084 1085 1086 1087 1088 1089
	 * 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.
	 */
Jan Beulich's avatar
Jan Beulich committed
1090
	static const char *const x86_cap_flags[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1091
		/* Intel-defined */
1092 1093 1094 1095
		"fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
		"cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
		"pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
		"fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
Linus Torvalds's avatar
Linus Torvalds committed
1096 1097

		/* AMD-defined */
1098
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
Linus Torvalds's avatar
Linus Torvalds committed
1099 1100
		NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1101 1102
		NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
		"3dnowext", "3dnow",
Linus Torvalds's avatar
Linus Torvalds committed
1103 1104 1105 1106 1107 1108 1109 1110

		/* 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) */
1111 1112 1113 1114 1115
		"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,
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117 1118
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

		/* Intel-defined (#2) */
1119
		"pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
1120
		"tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
1121
		NULL, NULL, "dca", "sse4_1", "sse4_2", NULL, NULL, "popcnt",
Linus Torvalds's avatar
Linus Torvalds committed
1122 1123
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

1124 1125
		/* VIA/Cyrix/Centaur-defined */
		NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1126
		"ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
1127 1128 1129
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

Linus Torvalds's avatar
Linus Torvalds committed
1130
		/* AMD-defined (#2) */
1131 1132 1133 1134
		"lahf_lm", "cmp_legacy", "svm", "extapic",
		"cr8_legacy", "abm", "sse4a", "misalignsse",
		"3dnowprefetch", "osvw", "ibs", "sse5",
		"skinit", "wdt", NULL, NULL,
Linus Torvalds's avatar
Linus Torvalds committed
1135
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1136
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1137 1138 1139 1140 1141 1142

		/* Auxiliary (Linux-defined) */
		"ida", 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, NULL, NULL, NULL,
Linus Torvalds's avatar
Linus Torvalds committed
1143
	};
Jan Beulich's avatar
Jan Beulich committed
1144
	static const char *const x86_power_flags[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1145 1146 1147 1148 1149
		"ts",	/* temperature sensor */
		"fid",  /* frequency id control */
		"vid",  /* voltage id control */
		"ttp",  /* thermal trip */
		"tm",
1150
		"stc",
1151 1152
		"100mhzsteps",
		"hwpstate",
1153 1154
		"",	/* tsc invariant mapped to constant_tsc */
		/* nothing */
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158
	};


#ifdef CONFIG_SMP
1159
	cpu = c->cpu_index;
Linus Torvalds's avatar
Linus Torvalds committed
1160 1161
#endif

1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
	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)cpu,
		   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");

Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175 1176
	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");
1177 1178

	if (cpu_has(c, X86_FEATURE_TSC)) {
1179
		unsigned int freq = cpufreq_quick_get((unsigned)cpu);
1180

1181 1182
		if (!freq)
			freq = cpu_khz;
Linus Torvalds's avatar
Linus Torvalds committed
1183
		seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1184
			   freq / 1000, (freq % 1000));
Linus Torvalds's avatar
Linus Torvalds committed
1185 1186 1187
	}

	/* Cache size */
1188
	if (c->x86_cache_size >= 0)
Linus Torvalds's avatar
Linus Torvalds committed
1189
		seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1190

Linus Torvalds's avatar
Linus Torvalds committed
1191
#ifdef CONFIG_SMP
1192
	if (smp_num_siblings * c->x86_max_cores > 1) {
1193
		seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1194 1195
		seq_printf(m, "siblings\t: %d\n",
			       cpus_weight(per_cpu(cpu_core_map, cpu)));
1196
		seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1197
		seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1198
	}
1199
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1200 1201

	seq_printf(m,
1202 1203 1204 1205 1206
		   "fpu\t\t: yes\n"
		   "fpu_exception\t: yes\n"
		   "cpuid level\t: %d\n"
		   "wp\t\t: yes\n"
		   "flags\t\t:",
Linus Torvalds's avatar
Linus Torvalds committed
1207 1208
		   c->cpuid_level);

1209 1210 1211 1212
	for (i = 0; i < 32*NCAPINTS; i++)
		if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
			seq_printf(m, " %s", x86_cap_flags[i]);

Linus Torvalds's avatar
Linus Torvalds committed
1213 1214 1215 1216
	seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
		   c->loops_per_jiffy/(500000/HZ),
		   (c->loops_per_jiffy/(5000/HZ)) % 100);

1217
	if (c->x86_tlbsize > 0)
Linus Torvalds's avatar
Linus Torvalds committed
1218 1219 1220 1221
		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);

1222
	seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
Linus Torvalds's avatar
Linus Torvalds committed
1223 1224 1225
		   c->x86_phys_bits, c->x86_virt_bits);

	seq_printf(m, "power management:");
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
	for (i = 0; i < 32; i++) {
		if (c->x86_power & (1 << i)) {
			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]);
			else
				seq_printf(m, " [%d]", i);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1236 1237
	}

1238
	seq_printf(m, "\n\n");
Linus Torvalds's avatar
Linus Torvalds committed
1239 1240 1241 1242 1243 1244

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
1245
	if (*pos == 0)	/* just in case, cpu 0 is not the first */
1246 1247
		*pos = first_cpu(cpu_online_map);
	if ((*pos) < NR_CPUS && cpu_online(*pos))
1248 1249
		return &cpu_data(*pos);
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1250 1251 1252 1253
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
1254
	*pos = next_cpu(*pos, cpu_online_map);
Linus Torvalds's avatar
Linus Torvalds committed
1255 1256 1257 1258 1259 1260 1261 1262
	return c_start(m, pos);
}

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

struct seq_operations cpuinfo_op = {
1263
	.start = c_start,
Linus Torvalds's avatar
Linus Torvalds committed
1264 1265 1266 1267
	.next =	c_next,
	.stop =	c_stop,
	.show =	show_cpuinfo,
};