arch/x86_64/kernel/setup.c

   1 /*
   2  *  linux/arch/x86-64/kernel/setup.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *
   6  *  Nov 2001 Dave Jones <davej@suse.de>
   7  *  Forked from i386 setup code.
   8  *
   9  *  $Id$
  10  */
  11
  12 /*
  13  * This file handles the architecture-dependent parts of initialization
  14  */
  15
  16 #include <linux/errno.h>
  17 #include <linux/sched.h>
  18 #include <linux/kernel.h>
  19 #include <linux/mm.h>
  20 #include <linux/stddef.h>
  21 #include <linux/unistd.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/slab.h>
  24 #include <linux/user.h>
  25 #include <linux/a.out.h>
  26 #include <linux/tty.h>
  27 #include <linux/ioport.h>
  28 #include <linux/delay.h>
  29 #include <linux/config.h>
  30 #include <linux/init.h>
  31 #include <linux/initrd.h>
  32 #include <linux/highmem.h>
  33 #include <linux/bootmem.h>
  34 #include <linux/module.h>
  35 #include <asm/processor.h>
  36 #include <linux/console.h>
  37 #include <linux/seq_file.h>
  38 #include <linux/root_dev.h>
  39 #include <linux/pci.h>
  40 #include <linux/acpi.h>
  41 #include <linux/kallsyms.h>
  42 #include <linux/edd.h>
  43 #include <asm/mtrr.h>
  44 #include <asm/uaccess.h>
  45 #include <asm/system.h>
  46 #include <asm/io.h>
  47 #include <asm/smp.h>
  48 #include <asm/msr.h>
  49 #include <asm/desc.h>
  50 #include <video/edid.h>
  51 #include <asm/e820.h>
  52 #include <asm/dma.h>
  53 #include <asm/mpspec.h>
  54 #include <asm/mmu_context.h>
  55 #include <asm/bootsetup.h>
  56 #include <asm/smp.h>
  57 #include <asm/proto.h>
  58
  59 /*
  60  * Machine setup..
  61  */
  62
  63 struct cpuinfo_x86 boot_cpu_data;
  64
  65 unsigned long mmu_cr4_features;
  66 EXPORT_SYMBOL_GPL(mmu_cr4_features);
  67
  68 int acpi_disabled;
  69 EXPORT_SYMBOL(acpi_disabled);
  70 #ifdef  CONFIG_ACPI_BOOT
  71 extern int __initdata acpi_ht;
  72 extern acpi_interrupt_flags     acpi_sci_flags;
  73 /* int __initdata acpi_force = 0; */
  74 #endif
  75
  76 /* For PCI or other memory-mapped resources */
  77 unsigned long pci_mem_start = 0x10000000;
  78
  79 unsigned long saved_video_mode;
  80
  81 int swiotlb;
  82 EXPORT_SYMBOL(swiotlb);
  83
  84 /*
  85  * Setup options
  86  */
  87 struct drive_info_struct { char dummy[32]; } drive_info;
  88 struct screen_info screen_info;
  89 struct sys_desc_table_struct {
  90         unsigned short length;
  91         unsigned char table[0];
  92 };
  93
  94 struct edid_info edid_info;
  95 struct e820map e820;
  96
  97 unsigned char aux_device_present;
  98
  99 extern int root_mountflags;
 100 extern char _text, _etext, _edata, _end;
 101
 102 char command_line[COMMAND_LINE_SIZE];
 103 char saved_command_line[COMMAND_LINE_SIZE];
 104
 105 struct resource standard_io_resources[] = {
 106         { "dma1", 0x00, 0x1f, IORESOURCE_BUSY | IORESOURCE_IO },
 107         { "pic1", 0x20, 0x21, IORESOURCE_BUSY | IORESOURCE_IO },
 108         { "timer", 0x40, 0x5f, IORESOURCE_BUSY | IORESOURCE_IO },
 109         { "keyboard", 0x60, 0x6f, IORESOURCE_BUSY | IORESOURCE_IO },
 110         { "dma page reg", 0x80, 0x8f, IORESOURCE_BUSY | IORESOURCE_IO },
 111         { "pic2", 0xa0, 0xa1, IORESOURCE_BUSY | IORESOURCE_IO },
 112         { "dma2", 0xc0, 0xdf, IORESOURCE_BUSY | IORESOURCE_IO },
 113         { "fpu", 0xf0, 0xff, IORESOURCE_BUSY | IORESOURCE_IO }
 114 };
 115
 116 #define STANDARD_IO_RESOURCES \
 117         (sizeof standard_io_resources / sizeof standard_io_resources[0])
 118
 119 struct resource code_resource = { "Kernel code", 0x100000, 0, IORESOURCE_MEM };
 120 struct resource data_resource = { "Kernel data", 0, 0, IORESOURCE_MEM };
 121 struct resource vram_resource = { "Video RAM area", 0xa0000, 0xbffff, IORESOURCE_BUSY | IORESOURCE_MEM };
 122
 123 #define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM)
 124
 125 static struct resource system_rom_resource = { "System ROM", 0xf0000, 0xfffff, IORESOURCE_ROM };
 126 static struct resource extension_rom_resource = { "Extension ROM", 0xe0000, 0xeffff, IORESOURCE_ROM };
 127
 128 static struct resource adapter_rom_resources[] = {
 129         { "Adapter ROM", 0xc8000, 0, IORESOURCE_ROM },
 130         { "Adapter ROM", 0, 0, IORESOURCE_ROM },
 131         { "Adapter ROM", 0, 0, IORESOURCE_ROM },
 132         { "Adapter ROM", 0, 0, IORESOURCE_ROM },
 133         { "Adapter ROM", 0, 0, IORESOURCE_ROM },
 134         { "Adapter ROM", 0, 0, IORESOURCE_ROM }
 135 };
 136
 137 #define ADAPTER_ROM_RESOURCES \
 138         (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
 139
 140 static struct resource video_rom_resource = { "Video ROM", 0xc0000, 0xc7fff, IORESOURCE_ROM };
 141
 142 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
 143
 144 static int __init checksum(unsigned char *rom, unsigned long length)
 145 {
 146         unsigned char *p, sum = 0;
 147
 148         for (p = rom; p < rom + length; p++)
 149                 sum += *p;
 150         return sum == 0;
 151 }
 152
 153 static void __init probe_roms(void)
 154 {
 155         unsigned long start, length, upper;
 156         unsigned char *rom;
 157         int           i;
 158
 159         /* video rom */
 160         upper = adapter_rom_resources[0].start;
 161         for (start = video_rom_resource.start; start < upper; start += 2048) {
 162                 rom = isa_bus_to_virt(start);
 163                 if (!romsignature(rom))
 164                         continue;
 165
 166                 video_rom_resource.start = start;
 167
 168                 /* 0 < length <= 0x7f * 512, historically */
 169                 length = rom[2] * 512;
 170
 171                 /* if checksum okay, trust length byte */
 172                 if (length && checksum(rom, length))
 173                         video_rom_resource.end = start + length - 1;
 174
 175                 request_resource(&iomem_resource, &video_rom_resource);
 176                 break;
 177                         }
 178
 179         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
 180         if (start < upper)
 181                 start = upper;
 182
 183         /* system rom */
 184         request_resource(&iomem_resource, &system_rom_resource);
 185         upper = system_rom_resource.start;
 186
 187         /* check for extension rom (ignore length byte!) */
 188         rom = isa_bus_to_virt(extension_rom_resource.start);
 189         if (romsignature(rom)) {
 190                 length = extension_rom_resource.end - extension_rom_resource.start + 1;
 191                 if (checksum(rom, length)) {
 192                         request_resource(&iomem_resource, &extension_rom_resource);
 193                         upper = extension_rom_resource.start;
 194                 }
 195         }
 196
 197         /* check for adapter roms on 2k boundaries */
 198         for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
 199                 rom = isa_bus_to_virt(start);
 200                 if (!romsignature(rom))
 201                         continue;
 202
 203                 /* 0 < length <= 0x7f * 512, historically */
 204                 length = rom[2] * 512;
 205
 206                 /* but accept any length that fits if checksum okay */
 207                 if (!length || start + length > upper || !checksum(rom, length))
 208                         continue;
 209
 210                 adapter_rom_resources[i].start = start;
 211                 adapter_rom_resources[i].end = start + length - 1;
 212                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
 213
 214                 start = adapter_rom_resources[i++].end & ~2047UL;
 215         }
 216 }
 217
 218 static __init void parse_cmdline_early (char ** cmdline_p)
 219 {
 220         char c = ' ', *to = command_line, *from = COMMAND_LINE;
 221         int len = 0;
 222
 223         /* Save unparsed command line copy for /proc/cmdline */
 224         memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
 225         saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
 226
 227         for (;;) {
 228                 if (c != ' ')
 229                         goto next_char;
 230
 231 #ifdef  CONFIG_SMP
 232                 /*
 233                  * If the BIOS enumerates physical processors before logical,
 234                  * maxcpus=N at enumeration-time can be used to disable HT.
 235                  */
 236                 else if (!memcmp(from, "maxcpus=", 8)) {
 237                         extern unsigned int maxcpus;
 238
 239                         maxcpus = simple_strtoul(from + 8, NULL, 0);
 240                 }
 241 #endif
 242 #ifdef CONFIG_ACPI_BOOT
 243                 /* "acpi=off" disables both ACPI table parsing and interpreter init */
 244                 if (!memcmp(from, "acpi=off", 8))
 245                         disable_acpi();
 246
 247                 if (!memcmp(from, "acpi=force", 10)) {
 248                         /* add later when we do DMI horrors: */
 249                         /* acpi_force = 1; */
 250                         acpi_disabled = 0;
 251                 }
 252
 253                 /* acpi=ht just means: do ACPI MADT parsing
 254                    at bootup, but don't enable the full ACPI interpreter */
 255                 if (!memcmp(from, "acpi=ht", 7)) {
 256                         acpi_ht = 1;
 257                 }
 258                 else if (!memcmp(from, "pci=noacpi", 10))
 259                         acpi_disable_pci();
 260                 else if (!memcmp(from, "acpi=noirq", 10))
 261                         acpi_noirq_set();
 262
 263                 else if (!memcmp(from, "acpi_sci=edge", 13))
 264                         acpi_sci_flags.trigger =  1;
 265                 else if (!memcmp(from, "acpi_sci=level", 14))
 266                         acpi_sci_flags.trigger = 3;
 267                 else if (!memcmp(from, "acpi_sci=high", 13))
 268                         acpi_sci_flags.polarity = 1;
 269                 else if (!memcmp(from, "acpi_sci=low", 12))
 270                         acpi_sci_flags.polarity = 3;
 271
 272                 /* acpi=strict disables out-of-spec workarounds */
 273                 else if (!memcmp(from, "acpi=strict", 11)) {
 274                         acpi_strict = 1;
 275                 }
 276 #endif
 277
 278                 if (!memcmp(from, "nolapic", 7) ||
 279                     !memcmp(from, "disableapic", 11))
 280                         disable_apic = 1;
 281
 282                 if (!memcmp(from, "noapic", 6))
 283                         skip_ioapic_setup = 1;
 284
 285                 if (!memcmp(from, "apic", 4)) {
 286                         skip_ioapic_setup = 0;
 287                         ioapic_force = 1;
 288                 }
 289
 290                 if (!memcmp(from, "mem=", 4))
 291                         parse_memopt(from+4, &from);
 292
 293 #ifdef CONFIG_DISCONTIGMEM
 294                 if (!memcmp(from, "numa=", 5))
 295                         numa_setup(from+5);
 296 #endif
 297
 298 #ifdef CONFIG_GART_IOMMU
 299                 if (!memcmp(from,"iommu=",6)) {
 300                         iommu_setup(from+6);
 301                 }
 302 #endif
 303
 304                 if (!memcmp(from,"oops=panic", 10))
 305                         panic_on_oops = 1;
 306
 307         next_char:
 308                 c = *(from++);
 309                 if (!c)
 310                         break;
 311                 if (COMMAND_LINE_SIZE <= ++len)
 312                         break;
 313                 *(to++) = c;
 314         }
 315         *to = '\0';
 316         *cmdline_p = command_line;
 317 }
 318
 319 #ifndef CONFIG_DISCONTIGMEM
 320 static void __init contig_initmem_init(void)
 321 {
 322         unsigned long bootmap_size, bootmap;
 323         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
 324         bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
 325         if (bootmap == -1L)
 326                 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
 327         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
 328         e820_bootmem_free(&contig_page_data, 0, end_pfn << PAGE_SHIFT);
 329         reserve_bootmem(bootmap, bootmap_size);
 330 }
 331 #endif
 332
 333 /* Use inline assembly to define this because the nops are defined
 334    as inline assembly strings in the include files and we cannot
 335    get them easily into strings. */
 336 asm("\t.data\nk8nops: "
 337     K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
 338     K8_NOP7 K8_NOP8);
 339
 340 extern unsigned char k8nops[];
 341 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
 342      NULL,
 343      k8nops,
 344      k8nops + 1,
 345      k8nops + 1 + 2,
 346      k8nops + 1 + 2 + 3,
 347      k8nops + 1 + 2 + 3 + 4,
 348      k8nops + 1 + 2 + 3 + 4 + 5,
 349      k8nops + 1 + 2 + 3 + 4 + 5 + 6,
 350      k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
 351 };
 352
 353 /* Replace instructions with better alternatives for this CPU type.
 354
 355    This runs before SMP is initialized to avoid SMP problems with
 356    self modifying code. This implies that assymetric systems where
 357    APs have less capabilities than the boot processor are not handled.
 358    In this case boot with "noreplacement". */
 359 void apply_alternatives(void *start, void *end)
 360 {
 361         struct alt_instr *a;
 362         int diff, i, k;
 363         for (a = start; (void *)a < end; a++) {
 364                 if (!boot_cpu_has(a->cpuid))
 365                         continue;
 366
 367                 BUG_ON(a->replacementlen > a->instrlen);
 368                 __inline_memcpy(a->instr, a->replacement, a->replacementlen);
 369                 diff = a->instrlen - a->replacementlen;
 370
 371                 /* Pad the rest with nops */
 372                 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
 373                         k = diff;
 374                         if (k > ASM_NOP_MAX)
 375                                 k = ASM_NOP_MAX;
 376                         __inline_memcpy(a->instr + i, k8_nops[k], k);
 377                 }
 378         }
 379 }
 380
 381 static int no_replacement __initdata = 0;
 382
 383 void __init alternative_instructions(void)
 384 {
 385         extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
 386         if (no_replacement)
 387                 return;
 388         apply_alternatives(__alt_instructions, __alt_instructions_end);
 389 }
 390
 391 static int __init noreplacement_setup(char *s)
 392 {
 393      no_replacement = 1;
 394      return 0;
 395 }
 396
 397 __setup("noreplacement", noreplacement_setup);
 398
 399 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
 400 unsigned char eddnr;
 401 struct edd_info edd[EDDMAXNR];
 402 unsigned int edd_disk80_sig;
 403 #ifdef CONFIG_EDD_MODULE
 404 EXPORT_SYMBOL(eddnr);
 405 EXPORT_SYMBOL(edd);
 406 EXPORT_SYMBOL(edd_disk80_sig);
 407 #endif
 408 /**
 409  * copy_edd() - Copy the BIOS EDD information
 410  *              from empty_zero_page into a safe place.
 411  *
 412  */
 413 static inline void copy_edd(void)
 414 {
 415      eddnr = EDD_NR;
 416      memcpy(edd, EDD_BUF, sizeof(edd));
 417      edd_disk80_sig = DISK80_SIGNATURE;
 418 }
 419 #else
 420 #define copy_edd() do {} while (0)
 421 #endif
 422
 423 void __init setup_arch(char **cmdline_p)
 424 {
 425         unsigned long low_mem_size;
 426         unsigned long kernel_end;
 427
 428         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
 429         drive_info = DRIVE_INFO;
 430         screen_info = SCREEN_INFO;
 431         edid_info = EDID_INFO;
 432         aux_device_present = AUX_DEVICE_INFO;
 433         saved_video_mode = SAVED_VIDEO_MODE;
 434
 435 #ifdef CONFIG_BLK_DEV_RAM
 436         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
 437         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
 438         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
 439 #endif
 440         setup_memory_region();
 441         copy_edd();
 442
 443         if (!MOUNT_ROOT_RDONLY)
 444                 root_mountflags &= ~MS_RDONLY;
 445         init_mm.start_code = (unsigned long) &_text;
 446         init_mm.end_code = (unsigned long) &_etext;
 447         init_mm.end_data = (unsigned long) &_edata;
 448         init_mm.brk = (unsigned long) &_end;
 449
 450         code_resource.start = virt_to_phys(&_text);
 451         code_resource.end = virt_to_phys(&_etext)-1;
 452         data_resource.start = virt_to_phys(&_etext);
 453         data_resource.end = virt_to_phys(&_edata)-1;
 454
 455         parse_cmdline_early(cmdline_p);
 456
 457         /*
 458          * partially used pages are not usable - thus
 459          * we are rounding upwards:
 460          */
 461         end_pfn = e820_end_of_ram();
 462
 463         check_efer();
 464
 465         init_memory_mapping();
 466
 467 #ifdef CONFIG_DISCONTIGMEM
 468         numa_initmem_init(0, end_pfn);
 469 #else
 470         contig_initmem_init();
 471 #endif
 472
 473         /* Reserve direct mapping */
 474         reserve_bootmem_generic(table_start << PAGE_SHIFT,
 475                                 (table_end - table_start) << PAGE_SHIFT);
 476
 477         /* reserve kernel */
 478         kernel_end = round_up(__pa_symbol(&_end),PAGE_SIZE);
 479         reserve_bootmem_generic(HIGH_MEMORY, kernel_end - HIGH_MEMORY);
 480
 481         /*
 482          * reserve physical page 0 - it's a special BIOS page on many boxes,
 483          * enabling clean reboots, SMP operation, laptop functions.
 484          */
 485         reserve_bootmem_generic(0, PAGE_SIZE);
 486
 487 #ifdef CONFIG_SMP
 488         /*
 489          * But first pinch a few for the stack/trampoline stuff
 490          * FIXME: Don't need the extra page at 4K, but need to fix
 491          * trampoline before removing it. (see the GDT stuff)
 492          */
 493         reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE);
 494
 495         /* Reserve SMP trampoline */
 496         reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, PAGE_SIZE);
 497 #endif
 498
 499 #ifdef CONFIG_ACPI_SLEEP
 500        /*
 501         * Reserve low memory region for sleep support.
 502         */
 503        acpi_reserve_bootmem();
 504 #endif
 505 #ifdef CONFIG_X86_LOCAL_APIC
 506         /*
 507          * Find and reserve possible boot-time SMP configuration:
 508          */
 509         find_smp_config();
 510 #endif
 511 #ifdef CONFIG_BLK_DEV_INITRD
 512         if (LOADER_TYPE && INITRD_START) {
 513                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
 514                         reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
 515                         initrd_start =
 516                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
 517                         initrd_end = initrd_start+INITRD_SIZE;
 518                 }
 519                 else {
 520                         printk(KERN_ERR "initrd extends beyond end of memory "
 521                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 522                             (unsigned long)(INITRD_START + INITRD_SIZE),
 523                             (unsigned long)(end_pfn << PAGE_SHIFT));
 524                         initrd_start = 0;
 525                 }
 526         }
 527 #endif
 528         paging_init();
 529
 530                 check_ioapic();
 531 #ifdef CONFIG_ACPI_BOOT
 532        /*
 533         * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
 534         * Must do this after paging_init (due to reliance on fixmap, and thus
 535         * the bootmem allocator) but before get_smp_config (to allow parsing
 536         * of MADT).
 537         */
 538         if (!acpi_disabled)
 539                 acpi_boot_init();
 540 #endif
 541 #ifdef CONFIG_X86_LOCAL_APIC
 542         /*
 543          * get boot-time SMP configuration:
 544          */
 545         if (smp_found_config)
 546                 get_smp_config();
 547         init_apic_mappings();
 548 #endif
 549
 550         /*
 551          * Request address space for all standard RAM and ROM resources
 552          * and also for regions reported as reserved by the e820.
 553          */
 554         probe_roms();
 555         e820_reserve_resources();
 556
 557         request_resource(&iomem_resource, &vram_resource);
 558
 559         {
 560         unsigned i;
 561         /* request I/O space for devices used on all i[345]86 PCs */
 562         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
 563                 request_resource(&ioport_resource, standard_io_resources+i);
 564         }
 565
 566         /* Will likely break when you have unassigned resources with more
 567            than 4GB memory and bridges that don't support more than 4GB.
 568            Doing it properly would require to use pci_alloc_consistent
 569            in this case. */
 570         low_mem_size = ((end_pfn << PAGE_SHIFT) + 0xfffff) & ~0xfffff;
 571         if (low_mem_size > pci_mem_start)
 572                 pci_mem_start = low_mem_size;
 573
 574 #ifdef CONFIG_GART_IOMMU
 575        iommu_hole_init();
 576 #endif
 577
 578 #ifdef CONFIG_VT
 579 #if defined(CONFIG_VGA_CONSOLE)
 580         conswitchp = &vga_con;
 581 #elif defined(CONFIG_DUMMY_CONSOLE)
 582         conswitchp = &dummy_con;
 583 #endif
 584 #endif
 585 }
 586
 587 static int __init get_model_name(struct cpuinfo_x86 *c)
 588 {
 589         unsigned int *v;
 590
 591         if (cpuid_eax(0x80000000) < 0x80000004)
 592                 return 0;
 593
 594         v = (unsigned int *) c->x86_model_id;
 595         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
 596         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
 597         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
 598         c->x86_model_id[48] = 0;
 599         return 1;
 600 }
 601
 602
 603 static void __init display_cacheinfo(struct cpuinfo_x86 *c)
 604 {
 605         unsigned int n, dummy, eax, ebx, ecx, edx;
 606
 607         n = cpuid_eax(0x80000000);
 608
 609         if (n >= 0x80000005) {
 610                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
 611                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
 612                         edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
 613                 c->x86_cache_size=(ecx>>24)+(edx>>24);
 614                 /* DTLB and ITLB together, but only 4K */
 615                 c->x86_tlbsize = ((ebx>>16)&0xff) + (ebx&0xff);
 616         }
 617
 618         if (n >= 0x80000006) {
 619                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
 620         ecx = cpuid_ecx(0x80000006);
 621         c->x86_cache_size = ecx >> 16;
 622                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
 623
 624         printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
 625                 c->x86_cache_size, ecx & 0xFF);
 626         }
 627
 628         if (n >= 0x80000007)
 629                 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
 630         if (n >= 0x80000008) {
 631                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
 632                 c->x86_virt_bits = (eax >> 8) & 0xff;
 633                 c->x86_phys_bits = eax & 0xff;
 634         }
 635 }
 636
 637
 638 static int __init init_amd(struct cpuinfo_x86 *c)
 639 {
 640         int r;
 641         int level;
 642
 643         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
 644            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
 645         clear_bit(0*32+31, &c->x86_capability);
 646
 647         /* C-stepping K8? */
 648         level = cpuid_eax(1);
 649         if ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58)
 650                 set_bit(X86_FEATURE_K8_C, &c->x86_capability);
 651
 652         r = get_model_name(c);
 653         if (!r) {
 654                 switch (c->x86) {
 655                 case 15:
 656                         /* Should distinguish Models here, but this is only
 657                            a fallback anyways. */
 658                         strcpy(c->x86_model_id, "Hammer");
 659                         break;
 660                 }
 661         }
 662         display_cacheinfo(c);
 663         return r;
 664 }
 665
 666 static void __init detect_ht(struct cpuinfo_x86 *c)
 667 {
 668 #ifdef CONFIG_SMP
 669         u32     eax, ebx, ecx, edx;
 670         int     index_lsb, index_msb, tmp;
 671         int     initial_apic_id;
 672         int     cpu = smp_processor_id();
 673
 674         if (!cpu_has(c, X86_FEATURE_HT))
 675                 return;
 676
 677         cpuid(1, &eax, &ebx, &ecx, &edx);
 678         smp_num_siblings = (ebx & 0xff0000) >> 16;
 679
 680         if (smp_num_siblings == 1) {
 681                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
 682         } else if (smp_num_siblings > 1) {
 683                 index_lsb = 0;
 684                 index_msb = 31;
 685                 /*
 686                  * At this point we only support two siblings per
 687                  * processor package.
 688                  */
 689                 if (smp_num_siblings > NR_CPUS) {
 690                         printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
 691                         smp_num_siblings = 1;
 692                         return;
 693                 }
 694                 tmp = smp_num_siblings;
 695                 while ((tmp & 1) == 0) {
 696                         tmp >>=1 ;
 697                         index_lsb++;
 698                 }
 699                 tmp = smp_num_siblings;
 700                 while ((tmp & 0x80000000 ) == 0) {
 701                         tmp <<=1 ;
 702                         index_msb--;
 703                 }
 704                 if (index_lsb != index_msb )
 705                         index_msb++;
 706                 initial_apic_id = ebx >> 24 & 0xff;
 707                 phys_proc_id[cpu] = initial_apic_id >> index_msb;
 708
 709                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
 710                        phys_proc_id[cpu]);
 711         }
 712 #endif
 713 }
 714
 715 #define LVL_1_INST      1
 716 #define LVL_1_DATA      2
 717 #define LVL_2           3
 718 #define LVL_3           4
 719 #define LVL_TRACE       5
 720
 721 struct _cache_table
 722 {
 723         unsigned char descriptor;
 724         char cache_type;
 725         short size;
 726 };
 727
 728 /* all the cache descriptor types we care about (no TLB or trace cache entries) */
 729 static struct _cache_table cache_table[] __initdata =
 730 {
 731         { 0x06, LVL_1_INST, 8 },
 732         { 0x08, LVL_1_INST, 16 },
 733         { 0x0a, LVL_1_DATA, 8 },
 734         { 0x0c, LVL_1_DATA, 16 },
 735         { 0x22, LVL_3,      512 },
 736         { 0x23, LVL_3,      1024 },
 737         { 0x25, LVL_3,      2048 },
 738         { 0x29, LVL_3,      4096 },
 739         { 0x2c, LVL_1_DATA, 32 },
 740         { 0x30, LVL_1_INST, 32 },
 741         { 0x39, LVL_2,      128 },
 742         { 0x3b, LVL_2,      128 },
 743         { 0x3c, LVL_2,      256 },
 744         { 0x41, LVL_2,      128 },
 745         { 0x42, LVL_2,      256 },
 746         { 0x43, LVL_2,      512 },
 747         { 0x44, LVL_2,      1024 },
 748         { 0x45, LVL_2,      2048 },
 749         { 0x66, LVL_1_DATA, 8 },
 750         { 0x67, LVL_1_DATA, 16 },
 751         { 0x68, LVL_1_DATA, 32 },
 752         { 0x70, LVL_TRACE,  12 },
 753         { 0x71, LVL_TRACE,  16 },
 754         { 0x72, LVL_TRACE,  32 },
 755         { 0x79, LVL_2,      128 },
 756         { 0x7a, LVL_2,      256 },
 757         { 0x7b, LVL_2,      512 },
 758         { 0x7c, LVL_2,      1024 },
 759         { 0x82, LVL_2,      256 },
 760         { 0x83, LVL_2,      512 },
 761         { 0x84, LVL_2,      1024 },
 762         { 0x85, LVL_2,      2048 },
 763         { 0x86, LVL_2,      512 },
 764         { 0x87, LVL_2,      1024 },
 765         { 0x00, 0, 0}
 766 };
 767
 768 static void __init init_intel(struct cpuinfo_x86 *c)
 769 {
 770         /* Cache sizes */
 771         unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0;
 772         unsigned n;
 773
 774         if (c->cpuid_level > 1) {
 775                 /* supports eax=2  call */
 776                 int i, j, n;
 777                 int regs[4];
 778                 unsigned char *dp = (unsigned char *)regs;
 779
 780                 /* Number of times to iterate */
 781                 n = cpuid_eax(2) & 0xFF;
 782
 783                 for ( i = 0 ; i < n ; i++ ) {
 784                         cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
 785
 786                         /* If bit 31 is set, this is an unknown format */
 787                         for ( j = 0 ; j < 3 ; j++ ) {
 788                                 if ( regs[j] < 0 ) regs[j] = 0;
 789                         }
 790
 791                         /* Byte 0 is level count, not a descriptor */
 792                         for ( j = 1 ; j < 16 ; j++ ) {
 793                                 unsigned char des = dp[j];
 794                                 unsigned char k = 0;
 795
 796                                 /* look up this descriptor in the table */
 797                                 while (cache_table[k].descriptor != 0)
 798                                 {
 799                                         if (cache_table[k].descriptor == des) {
 800                                                 switch (cache_table[k].cache_type) {
 801                                                 case LVL_1_INST:
 802                                                         l1i += cache_table[k].size;
 803                                                         break;
 804                                                 case LVL_1_DATA:
 805                                                         l1d += cache_table[k].size;
 806                                                         break;
 807                                                 case LVL_2:
 808                                                         l2 += cache_table[k].size;
 809                                                         break;
 810                                                 case LVL_3:
 811                                                         l3 += cache_table[k].size;
 812                                                         break;
 813                                                 case LVL_TRACE:
 814                                                         trace += cache_table[k].size;
 815                                                         break;
 816                                                 }
 817
 818                                                 break;
 819                                         }
 820
 821                                         k++;
 822                                 }
 823                         }
 824                 }
 825
 826                 if (trace)
 827                         printk (KERN_INFO "CPU: Trace cache: %dK uops", trace);
 828                 else if (l1i)
 829                         printk (KERN_INFO "CPU: L1 I cache: %dK", l1i);
 830                 if (l1d)
 831                         printk(", L1 D cache: %dK\n", l1d);
 832                 else
 833                         printk("\n");
 834                 if (l2)
 835                         printk(KERN_INFO "CPU: L2 cache: %dK\n", l2);
 836                 if (l3)
 837                         printk(KERN_INFO "CPU: L3 cache: %dK\n", l3);
 838
 839                 c->x86_cache_size = l2 ? l2 : (l1i+l1d);
 840         }
 841
 842         n = cpuid_eax(0x80000000);
 843         if (n >= 0x80000008) {
 844                 unsigned eax = cpuid_eax(0x80000008);
 845                 c->x86_virt_bits = (eax >> 8) & 0xff;
 846                 c->x86_phys_bits = eax & 0xff;
 847         }
 848
 849         if (c->x86 == 15)
 850                 c->x86_cache_alignment = c->x86_clflush_size * 2;
 851 }
 852
 853 void __init get_cpu_vendor(struct cpuinfo_x86 *c)
 854 {
 855         char *v = c->x86_vendor_id;
 856
 857         if (!strcmp(v, "AuthenticAMD"))
 858                 c->x86_vendor = X86_VENDOR_AMD;
 859         else if (!strcmp(v, "GenuineIntel"))
 860                 c->x86_vendor = X86_VENDOR_INTEL;
 861         else
 862                 c->x86_vendor = X86_VENDOR_UNKNOWN;
 863 }
 864
 865 struct cpu_model_info {
 866         int vendor;
 867         int family;
 868         char *model_names[16];
 869 };
 870
 871 /* Do some early cpuid on the boot CPU to get some parameter that are
 872    needed before check_bugs. Everything advanced is in identify_cpu
 873    below. */
 874 void __init early_identify_cpu(struct cpuinfo_x86 *c)
 875 {
 876         u32 tfms;
 877
 878         c->loops_per_jiffy = loops_per_jiffy;
 879         c->x86_cache_size = -1;
 880         c->x86_vendor = X86_VENDOR_UNKNOWN;
 881         c->x86_model = c->x86_mask = 0; /* So far unknown... */
 882         c->x86_vendor_id[0] = '\0'; /* Unset */
 883         c->x86_model_id[0] = '\0';  /* Unset */
 884         c->x86_clflush_size = 64;
 885         c->x86_cache_alignment = c->x86_clflush_size;
 886         memset(&c->x86_capability, 0, sizeof c->x86_capability);
 887
 888         /* Get vendor name */
 889         cpuid(0x00000000, &c->cpuid_level,
 890               (int *)&c->x86_vendor_id[0],
 891               (int *)&c->x86_vendor_id[8],
 892               (int *)&c->x86_vendor_id[4]);
 893
 894         get_cpu_vendor(c);
 895
 896         /* Initialize the standard set of capabilities */
 897         /* Note that the vendor-specific code below might override */
 898
 899         /* Intel-defined flags: level 0x00000001 */
 900         if (c->cpuid_level >= 0x00000001) {
 901                 __u32 misc;
 902                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
 903                       &c->x86_capability[0]);
 904                 c->x86 = (tfms >> 8) & 0xf;
 905                 c->x86_model = (tfms >> 4) & 0xf;
 906                 c->x86_mask = tfms & 0xf;
 907                 if (c->x86 == 0xf) {
 908                         c->x86 += (tfms >> 20) & 0xff;
 909                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
 910                 }
 911                 if (c->x86_capability[0] & (1<<19))
 912                 c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
 913         } else {
 914                 /* Have CPUID level 0 only - unheard of */
 915                 c->x86 = 4;
 916         }
 917 }
 918
 919 /*
 920  * This does the hard work of actually picking apart the CPU stuff...
 921  */
 922 void __init identify_cpu(struct cpuinfo_x86 *c)
 923 {
 924         int i;
 925         u32 xlvl;
 926
 927         early_identify_cpu(c);
 928
 929         /* AMD-defined flags: level 0x80000001 */
 930         xlvl = cpuid_eax(0x80000000);
 931         if ( (xlvl & 0xffff0000) == 0x80000000 ) {
 932                 if ( xlvl >= 0x80000001 )
 933                         c->x86_capability[1] = cpuid_edx(0x80000001);
 934                 if ( xlvl >= 0x80000004 )
 935                         get_model_name(c); /* Default name */
 936         }
 937
 938         /* Transmeta-defined flags: level 0x80860001 */
 939         xlvl = cpuid_eax(0x80860000);
 940         if ( (xlvl & 0xffff0000) == 0x80860000 ) {
 941                 if (  xlvl >= 0x80860001 )
 942                         c->x86_capability[2] = cpuid_edx(0x80860001);
 943         }
 944
 945         /*
 946          * Vendor-specific initialization.  In this section we
 947          * canonicalize the feature flags, meaning if there are
 948          * features a certain CPU supports which CPUID doesn't
 949          * tell us, CPUID claiming incorrect flags, or other bugs,
 950          * we handle them here.
 951          *
 952          * At the end of this section, c->x86_capability better
 953          * indicate the features this CPU genuinely supports!
 954          */
 955         switch ( c->x86_vendor ) {
 956
 957                 case X86_VENDOR_AMD:
 958                         init_amd(c);
 959                         break;
 960
 961                 case X86_VENDOR_INTEL:
 962                         init_intel(c);
 963                         break;
 964
 965                 case X86_VENDOR_UNKNOWN:
 966                 default:
 967                         display_cacheinfo(c);
 968                         break;
 969         }
 970
 971         select_idle_routine(c);
 972         detect_ht(c);
 973
 974         /*
 975          * On SMP, boot_cpu_data holds the common feature set between
 976          * all CPUs; so make sure that we indicate which features are
 977          * common between the CPUs.  The first time this routine gets
 978          * executed, c == &boot_cpu_data.
 979          */
 980         if ( c != &boot_cpu_data ) {
 981                 /* AND the already accumulated flags with these */
 982                 for ( i = 0 ; i < NCAPINTS ; i++ )
 983                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
 984         }
 985
 986         mcheck_init(c);
 987 }
 988
 989
 990 void __init print_cpu_info(struct cpuinfo_x86 *c)
 991 {
 992         if (c->x86_model_id[0])
 993                 printk("%s", c->x86_model_id);
 994
 995         if (c->x86_mask || c->cpuid_level >= 0)
 996                 printk(" stepping %02x\n", c->x86_mask);
 997         else
 998                 printk("\n");
 999 }
1000
1001 /*
1002  *      Get CPU information for use by the procfs.
1003  */
1004
1005 static int show_cpuinfo(struct seq_file *m, void *v)
1006 {
1007         struct cpuinfo_x86 *c = v;
1008
1009         /*
1010          * These flag bits must match the definitions in <asm/cpufeature.h>.
1011          * NULL means this bit is undefined or reserved; either way it doesn't
1012          * have meaning as far as Linux is concerned.  Note that it's important
1013          * to realize there is a difference between this table and CPUID -- if
1014          * applications want to get the raw CPUID data, they should access
1015          * /dev/cpu/<cpu_nr>/cpuid instead.
1016          */
1017         static char *x86_cap_flags[] = {
1018                 /* Intel-defined */
1019                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1020                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1021                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1022                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
1023
1024                 /* AMD-defined */
1025                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1026                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1027                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1028                 NULL, NULL, NULL, NULL, NULL, "lm", "3dnowext", "3dnow",
1029
1030                 /* Transmeta-defined */
1031                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1032                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1033                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1034                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1035
1036                 /* Other (Linux-defined) */
1037                 "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr", NULL, NULL, NULL, NULL,
1038                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1039                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1040                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1041
1042                 /* Intel-defined (#2) */
1043                 "pni", NULL, NULL, "monitor", "ds_cpl", NULL, NULL, "tm2",
1044                 "est", NULL, "cid", NULL, NULL, "cmpxchg16b", NULL, NULL,
1045                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1046                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1047         };
1048         static char *x86_power_flags[] = {
1049                 "ts",   /* temperature sensor */
1050                 "fid",  /* frequency id control */
1051                 "vid",  /* voltage id control */
1052                 "ttp",  /* thermal trip */
1053         };
1054
1055
1056 #ifdef CONFIG_SMP
1057         if (!cpu_online(c-cpu_data))
1058                 return 0;
1059 #endif
1060
1061         seq_printf(m,"processor\t: %u\n"
1062                      "vendor_id\t: %s\n"
1063                      "cpu family\t: %d\n"
1064                      "model\t\t: %d\n"
1065                      "model name\t: %s\n",
1066                      (unsigned)(c-cpu_data),
1067                      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1068                      c->x86,
1069                      (int)c->x86_model,
1070                      c->x86_model_id[0] ? c->x86_model_id : "unknown");
1071
1072         if (c->x86_mask || c->cpuid_level >= 0)
1073                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1074         else
1075                 seq_printf(m, "stepping\t: unknown\n");
1076
1077         if (cpu_has(c,X86_FEATURE_TSC)) {
1078                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1079                              cpu_khz / 1000, (cpu_khz % 1000));
1080         }
1081
1082         /* Cache size */
1083         if (c->x86_cache_size >= 0)
1084                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1085
1086 #ifdef CONFIG_X86_HT
1087         if (cpu_has_ht) {
1088                 seq_printf(m, "physical id\t: %d\n", phys_proc_id[c - cpu_data]);
1089                 seq_printf(m, "siblings\t: %d\n", smp_num_siblings);
1090         }
1091 #endif
1092
1093         seq_printf(m,
1094                 "fpu\t\t: yes\n"
1095                 "fpu_exception\t: yes\n"
1096                 "cpuid level\t: %d\n"
1097                 "wp\t\t: yes\n"
1098                 "flags\t\t:",
1099                    c->cpuid_level);
1100
1101         {
1102                 int i;
1103                 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1104                         if ( test_bit(i, &c->x86_capability) &&
1105                              x86_cap_flags[i] != NULL )
1106                                 seq_printf(m, " %s", x86_cap_flags[i]);
1107         }
1108
1109         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1110                    c->loops_per_jiffy/(500000/HZ),
1111                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1112
1113         if (c->x86_tlbsize > 0)
1114                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1115         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1116         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1117
1118         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
1119                    c->x86_phys_bits, c->x86_virt_bits);
1120
1121         seq_printf(m, "power management:");
1122         {
1123                 unsigned i;
1124                 for (i = 0; i < 32; i++)
1125                         if (c->x86_power & (1 << i)) {
1126                                 if (i < ARRAY_SIZE(x86_power_flags))
1127                                         seq_printf(m, " %s", x86_power_flags[i]);
1128                                 else
1129                                         seq_printf(m, " [%d]", i);
1130                         }
1131         }
1132
1133         seq_printf(m, "\n\n");
1134
1135         return 0;
1136 }
1137
1138 static void *c_start(struct seq_file *m, loff_t *pos)
1139 {
1140         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1141 }
1142
1143 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1144 {
1145         ++*pos;
1146         return c_start(m, pos);
1147 }
1148
1149 static void c_stop(struct seq_file *m, void *v)
1150 {
1151 }
1152
1153 struct seq_operations cpuinfo_op = {
1154         .start =c_start,
1155         .next = c_next,
1156         .stop = c_stop,
1157         .show = show_cpuinfo,
1158 };