开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
setup.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：81k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  *  linux/arch/i386/kernel/setup.c
  3.  *
  4.  *  Copyright (C) 1995  Linus Torvalds
  5.  *
  6.  *  Enhanced CPU type detection by Mike Jagdis, Patrick St. Jean
  7.  *  and Martin Mares, November 1997.
  8.  *
  9.  *  Force Cyrix 6x86(MX) and M II processors to report MTRR capability
  10.  *  and Cyrix "coma bug" recognition by
  11.  *      Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu> February 1999.
  12.  * 
  13.  *  Force Centaur C6 processors to report MTRR capability.
  14.  *      Bart Hartgers <bart@etpmod.phys.tue.nl>, May 1999.
  15.  *
  16.  *  Intel Mobile Pentium II detection fix. Sean Gilley, June 1999.
  17.  *
  18.  *  IDT Winchip tweaks, misc clean ups.
  19.  * Dave Jones <davej@suse.de>, August 1999
  20.  *
  21.  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
  22.  *
  23.  *  Better detection of Centaur/IDT WinChip models.
  24.  *      Bart Hartgers <bart@etpmod.phys.tue.nl>, August 1999.
  25.  *
  26.  *  Memory region support
  27.  * David Parsons <orc@pell.chi.il.us>, July-August 1999
  28.  *
  29.  *  Cleaned up cache-detection code
  30.  * Dave Jones <davej@suse.de>, October 1999
  31.  *
  32.  * Added proper L2 cache detection for Coppermine
  33.  * Dragan Stancevic <visitor@valinux.com>, October 1999
  34.  *
  35.  *  Added the original array for capability flags but forgot to credit 
  36.  *  myself :) (~1998) Fixed/cleaned up some cpu_model_info and other stuff
  37.  *   Jauder Ho <jauderho@carumba.com>, January 2000
  38.  *
  39.  *  Detection for Celeron coppermine, identify_cpu() overhauled,
  40.  *  and a few other clean ups.
  41.  *  Dave Jones <davej@suse.de>, April 2000
  42.  *
  43.  *  Pentium III FXSR, SSE support
  44.  *  General FPU state handling cleanups
  45.  * Gareth Hughes <gareth@valinux.com>, May 2000
  46.  *
  47.  *  Added proper Cascades CPU and L2 cache detection for Cascades
  48.  *  and 8-way type cache happy bunch from Intel:^)
  49.  *  Dragan Stancevic <visitor@valinux.com>, May 2000 
  50.  *
  51.  *  Forward port AMD Duron errata T13 from 2.2.17pre
  52.  *  Dave Jones <davej@suse.de>, August 2000
  53.  *
  54.  *  Forward port lots of fixes/improvements from 2.2.18pre
  55.  *  Cyrix III, Pentium IV support.
  56.  *  Dave Jones <davej@suse.de>, October 2000
  57.  *
  58.  *  Massive cleanup of CPU detection and bug handling;
  59.  *  Transmeta CPU detection,
  60.  *  H. Peter Anvin <hpa@zytor.com>, November 2000
  61.  *
  62.  *  Added E820 sanitization routine (removes overlapping memory regions);
  63.  *  Brian Moyle <bmoyle@mvista.com>, February 2001
  64.  *
  65.  *  VIA C3 Support.
  66.  *  Dave Jones <davej@suse.de>, March 2001
  67.  *
  68.  *  AMD Athlon/Duron/Thunderbird bluesmoke support.
  69.  *  Dave Jones <davej@suse.de>, April 2001.
  70.  *
  71.  *  CacheSize bug workaround updates for AMD, Intel & VIA Cyrix.
  72.  *  Dave Jones <davej@suse.de>, September, October 2001.
  73.  *
  74.  */
  76. /*
  77.  * This file handles the architecture-dependent parts of initialization
  78.  */
  80. #include <linux/errno.h>
  81. #include <linux/sched.h>
  82. #include <linux/kernel.h>
  83. #include <linux/mm.h>
  84. #include <linux/stddef.h>
  85. #include <linux/unistd.h>
  86. #include <linux/ptrace.h>
  87. #include <linux/slab.h>
  88. #include <linux/user.h>
  89. #include <linux/a.out.h>
  90. #include <linux/tty.h>
  91. #include <linux/ioport.h>
  92. #include <linux/delay.h>
  93. #include <linux/config.h>
  94. #include <linux/init.h>
  95. #include <linux/apm_bios.h>
  96. #ifdef CONFIG_BLK_DEV_RAM
  97. #include <linux/blk.h>
  98. #endif
  99. #include <linux/highmem.h>
  100. #include <linux/bootmem.h>
  101. #include <linux/pci.h>
  102. #include <linux/pci_ids.h>
  103. #include <linux/seq_file.h>
  104. #include <asm/processor.h>
  105. #include <linux/console.h>
  106. #include <asm/mtrr.h>
  107. #include <asm/uaccess.h>
  108. #include <asm/system.h>
  109. #include <asm/io.h>
  110. #include <asm/smp.h>
  111. #include <asm/cobalt.h>
  112. #include <asm/msr.h>
  113. #include <asm/desc.h>
  114. #include <asm/e820.h>
  115. #include <asm/dma.h>
  116. #include <asm/mpspec.h>
  117. #include <asm/mmu_context.h>
  118. /*
  119.  * Machine setup..
  120.  */
  122. char ignore_irq13; /* set if exception 16 works */
  123. struct cpuinfo_x86 boot_cpu_data = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  125. unsigned long mmu_cr4_features;
  127. /*
  128.  * Bus types ..
  129.  */
  130. #ifdef CONFIG_EISA
  131. int EISA_bus;
  132. #endif
  133. int MCA_bus;
  135. /* for MCA, but anyone else can use it if they want */
  136. unsigned int machine_id;
  137. unsigned int machine_submodel_id;
  138. unsigned int BIOS_revision;
  139. unsigned int mca_pentium_flag;
  141. /* For PCI or other memory-mapped resources */
  142. unsigned long pci_mem_start = 0x10000000;
  144. /* user-defined highmem size */
  145. static unsigned int highmem_pages __initdata = -1;
  147. /*
  148.  * Setup options
  149.  */
  150. struct drive_info_struct { char dummy[32]; } drive_info;
  151. struct screen_info screen_info;
  152. struct apm_info apm_info;
  153. struct sys_desc_table_struct {
  154. unsigned short length;
  155. unsigned char table[0];
  156. };
  158. struct e820map e820;
  160. unsigned char aux_device_present;
  162. extern void mcheck_init(struct cpuinfo_x86 *c);
  163. extern void dmi_scan_machine(void);
  164. extern int root_mountflags;
  165. extern char _text, _etext, _edata, _end;
  167. static int have_cpuid_p(void) __init;
  169. static int disable_x86_serial_nr __initdata = 1;
  170. static int disable_x86_ht __initdata = 0;
  171. static u32 disabled_x86_caps[NCAPINTS] __initdata = { 0 };
  172. extern int blk_nohighio;
  174. int enable_acpi_smp_table;
  176. /*
  177.  * This is set up by the setup-routine at boot-time
  178.  */
  179. #define PARAM ((unsigned char *)empty_zero_page)
  180. #define SCREEN_INFO (*(struct screen_info *) (PARAM+0))
  181. #define EXT_MEM_K (*(unsigned short *) (PARAM+2))
  182. #define ALT_MEM_K (*(unsigned long *) (PARAM+0x1e0))
  183. #define E820_MAP_NR (*(char*) (PARAM+E820NR))
  184. #define E820_MAP    ((struct e820entry *) (PARAM+E820MAP))
  185. #define APM_BIOS_INFO (*(struct apm_bios_info *) (PARAM+0x40))
  186. #define DRIVE_INFO (*(struct drive_info_struct *) (PARAM+0x80))
  187. #define SYS_DESC_TABLE (*(struct sys_desc_table_struct*)(PARAM+0xa0))
  188. #define MOUNT_ROOT_RDONLY (*(unsigned short *) (PARAM+0x1F2))
  189. #define RAMDISK_FLAGS (*(unsigned short *) (PARAM+0x1F8))
  190. #define ORIG_ROOT_DEV (*(unsigned short *) (PARAM+0x1FC))
  191. #define AUX_DEVICE_INFO (*(unsigned char *) (PARAM+0x1FF))
  192. #define LOADER_TYPE (*(unsigned char *) (PARAM+0x210))
  193. #define KERNEL_START (*(unsigned long *) (PARAM+0x214))
  194. #define INITRD_START (*(unsigned long *) (PARAM+0x218))
  195. #define INITRD_SIZE (*(unsigned long *) (PARAM+0x21c))
  196. #define COMMAND_LINE ((char *) (PARAM+2048))
  197. #define COMMAND_LINE_SIZE 256
  199. #define RAMDISK_IMAGE_START_MASK   0x07FF
  200. #define RAMDISK_PROMPT_FLAG 0x8000
  201. #define RAMDISK_LOAD_FLAG 0x4000
  203. #ifdef CONFIG_VISWS
  204. char visws_board_type = -1;
  205. char visws_board_rev = -1;
  207. #define PIIX_PM_START 0x0F80
  209. #define SIO_GPIO_START 0x0FC0
  211. #define SIO_PM_START 0x0FC8
  213. #define PMBASE PIIX_PM_START
  214. #define GPIREG0 (PMBASE+0x30)
  215. #define GPIREG(x) (GPIREG0+((x)/8))
  216. #define PIIX_GPI_BD_ID1 18
  217. #define PIIX_GPI_BD_REG GPIREG(PIIX_GPI_BD_ID1)
  219. #define PIIX_GPI_BD_SHIFT (PIIX_GPI_BD_ID1 % 8)
  221. #define SIO_INDEX 0x2e
  222. #define SIO_DATA 0x2f
  224. #define SIO_DEV_SEL 0x7
  225. #define SIO_DEV_ENB 0x30
  226. #define SIO_DEV_MSB 0x60
  227. #define SIO_DEV_LSB 0x61
  229. #define SIO_GP_DEV 0x7
  231. #define SIO_GP_BASE SIO_GPIO_START
  232. #define SIO_GP_MSB (SIO_GP_BASE>>8)
  233. #define SIO_GP_LSB (SIO_GP_BASE&0xff)
  235. #define SIO_GP_DATA1 (SIO_GP_BASE+0)
  237. #define SIO_PM_DEV 0x8
  239. #define SIO_PM_BASE SIO_PM_START
  240. #define SIO_PM_MSB (SIO_PM_BASE>>8)
  241. #define SIO_PM_LSB (SIO_PM_BASE&0xff)
  242. #define SIO_PM_INDEX (SIO_PM_BASE+0)
  243. #define SIO_PM_DATA (SIO_PM_BASE+1)
  245. #define SIO_PM_FER2 0x1
  247. #define SIO_PM_GP_EN 0x80
  249. static void __init visws_get_board_type_and_rev(void)
  250. {
  251. int raw;
  253. visws_board_type = (char)(inb_p(PIIX_GPI_BD_REG) & PIIX_GPI_BD_REG)
  254.  >> PIIX_GPI_BD_SHIFT;
  255. /*
  256.  * Get Board rev.
  257.  * First, we have to initialize the 307 part to allow us access
  258.  * to the GPIO registers.  Let's map them at 0x0fc0 which is right
  259.  * after the PIIX4 PM section.
  260.  */
  261. outb_p(SIO_DEV_SEL, SIO_INDEX);
  262. outb_p(SIO_GP_DEV, SIO_DATA); /* Talk to GPIO regs. */
  263.     
  264. outb_p(SIO_DEV_MSB, SIO_INDEX);
  265. outb_p(SIO_GP_MSB, SIO_DATA); /* MSB of GPIO base address */
  267. outb_p(SIO_DEV_LSB, SIO_INDEX);
  268. outb_p(SIO_GP_LSB, SIO_DATA); /* LSB of GPIO base address */
  270. outb_p(SIO_DEV_ENB, SIO_INDEX);
  271. outb_p(1, SIO_DATA); /* Enable GPIO registers. */
  272.     
  273. /*
  274.  * Now, we have to map the power management section to write
  275.  * a bit which enables access to the GPIO registers.
  276.  * What lunatic came up with this shit?
  277.  */
  278. outb_p(SIO_DEV_SEL, SIO_INDEX);
  279. outb_p(SIO_PM_DEV, SIO_DATA); /* Talk to GPIO regs. */
  281. outb_p(SIO_DEV_MSB, SIO_INDEX);
  282. outb_p(SIO_PM_MSB, SIO_DATA); /* MSB of PM base address */
  283.     
  284. outb_p(SIO_DEV_LSB, SIO_INDEX);
  285. outb_p(SIO_PM_LSB, SIO_DATA); /* LSB of PM base address */
  287. outb_p(SIO_DEV_ENB, SIO_INDEX);
  288. outb_p(1, SIO_DATA); /* Enable PM registers. */
  289.     
  290. /*
  291.  * Now, write the PM register which enables the GPIO registers.
  292.  */
  293. outb_p(SIO_PM_FER2, SIO_PM_INDEX);
  294. outb_p(SIO_PM_GP_EN, SIO_PM_DATA);
  295.     
  296. /*
  297.  * Now, initialize the GPIO registers.
  298.  * We want them all to be inputs which is the
  299.  * power on default, so let's leave them alone.
  300.  * So, let's just read the board rev!
  301.  */
  302. raw = inb_p(SIO_GP_DATA1);
  303. raw &= 0x7f; /* 7 bits of valid board revision ID. */
  305. if (visws_board_type == VISWS_320) {
  306. if (raw < 0x6) {
  307. visws_board_rev = 4;
  308. } else if (raw < 0xc) {
  309. visws_board_rev = 5;
  310. } else {
  311. visws_board_rev = 6;
  313. }
  314. } else if (visws_board_type == VISWS_540) {
  315. visws_board_rev = 2;
  316. } else {
  317. visws_board_rev = raw;
  318. }
  320. printk(KERN_INFO "Silicon Graphics %s (rev %d)n",
  321. visws_board_type == VISWS_320 ? "320" :
  322. (visws_board_type == VISWS_540 ? "540" :
  323. "unknown"),
  324. visws_board_rev);
  325. }
  326. #endif
  329. static char command_line[COMMAND_LINE_SIZE];
  330.        char saved_command_line[COMMAND_LINE_SIZE];
  332. struct resource standard_io_resources[] = {
  333. { "dma1", 0x00, 0x1f, IORESOURCE_BUSY },
  334. { "pic1", 0x20, 0x3f, IORESOURCE_BUSY },
  335. { "timer", 0x40, 0x5f, IORESOURCE_BUSY },
  336. { "keyboard", 0x60, 0x6f, IORESOURCE_BUSY },
  337. { "dma page reg", 0x80, 0x8f, IORESOURCE_BUSY },
  338. { "pic2", 0xa0, 0xbf, IORESOURCE_BUSY },
  339. { "dma2", 0xc0, 0xdf, IORESOURCE_BUSY },
  340. { "fpu", 0xf0, 0xff, IORESOURCE_BUSY }
  341. };
  343. #define STANDARD_IO_RESOURCES (sizeof(standard_io_resources)/sizeof(struct resource))
  345. static struct resource code_resource = { "Kernel code", 0x100000, 0 };
  346. static struct resource data_resource = { "Kernel data", 0, 0 };
  347. static struct resource vram_resource = { "Video RAM area", 0xa0000, 0xbffff, IORESOURCE_BUSY };
  349. /* System ROM resources */
  350. #define MAXROMS 6
  351. static struct resource rom_resources[MAXROMS] = {
  352. { "System ROM", 0xF0000, 0xFFFFF, IORESOURCE_BUSY },
  353. { "Video ROM", 0xc0000, 0xc7fff, IORESOURCE_BUSY }
  354. };
  356. #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
  358. static void __init probe_roms(void)
  359. {
  360. int roms = 1;
  361. unsigned long base;
  362. unsigned char *romstart;
  364. request_resource(&iomem_resource, rom_resources+0);
  366. /* Video ROM is standard at C000:0000 - C7FF:0000, check signature */
  367. for (base = 0xC0000; base < 0xE0000; base += 2048) {
  368. romstart = bus_to_virt(base);
  369. if (!romsignature(romstart))
  370. continue;
  371. request_resource(&iomem_resource, rom_resources + roms);
  372. roms++;
  373. break;
  374. }
  376. /* Extension roms at C800:0000 - DFFF:0000 */
  377. for (base = 0xC8000; base < 0xE0000; base += 2048) {
  378. unsigned long length;
  380. romstart = bus_to_virt(base);
  381. if (!romsignature(romstart))
  382. continue;
  383. length = romstart[2] * 512;
  384. if (length) {
  385. unsigned int i;
  386. unsigned char chksum;
  388. chksum = 0;
  389. for (i = 0; i < length; i++)
  390. chksum += romstart[i];
  392. /* Good checksum? */
  393. if (!chksum) {
  394. rom_resources[roms].start = base;
  395. rom_resources[roms].end = base + length - 1;
  396. rom_resources[roms].name = "Extension ROM";
  397. rom_resources[roms].flags = IORESOURCE_BUSY;
  399. request_resource(&iomem_resource, rom_resources + roms);
  400. roms++;
  401. if (roms >= MAXROMS)
  402. return;
  403. }
  404. }
  405. }
  407. /* Final check for motherboard extension rom at E000:0000 */
  408. base = 0xE0000;
  409. romstart = bus_to_virt(base);
  411. if (romsignature(romstart)) {
  412. rom_resources[roms].start = base;
  413. rom_resources[roms].end = base + 65535;
  414. rom_resources[roms].name = "Extension ROM";
  415. rom_resources[roms].flags = IORESOURCE_BUSY;
  417. request_resource(&iomem_resource, rom_resources + roms);
  418. }
  419. }
  421. static void __init limit_regions (unsigned long long size)
  422. {
  423. unsigned long long current_addr = 0;
  424. int i;
  426. for (i = 0; i < e820.nr_map; i++) {
  427. if (e820.map[i].type == E820_RAM) {
  428. current_addr = e820.map[i].addr + e820.map[i].size;
  429. if (current_addr >= size) {
  430. e820.map[i].size -= current_addr-size;
  431. e820.nr_map = i + 1;
  432. return;
  433. }
  434. }
  435. }
  436. }
  437. static void __init add_memory_region(unsigned long long start,
  438.                                   unsigned long long size, int type)
  439. {
  440. int x = e820.nr_map;
  442. if (x == E820MAX) {
  443.     printk(KERN_ERR "Ooops! Too many entries in the memory map!n");
  444.     return;
  445. }
  447. e820.map[x].addr = start;
  448. e820.map[x].size = size;
  449. e820.map[x].type = type;
  450. e820.nr_map++;
  451. } /* add_memory_region */
  453. #define E820_DEBUG 1
  455. static void __init print_memory_map(char *who)
  456. {
  457. int i;
  459. for (i = 0; i < e820.nr_map; i++) {
  460. printk(" %s: %016Lx - %016Lx ", who,
  461. e820.map[i].addr,
  462. e820.map[i].addr + e820.map[i].size);
  463. switch (e820.map[i].type) {
  464. case E820_RAM: printk("(usable)n");
  465. break;
  466. case E820_RESERVED:
  467. printk("(reserved)n");
  468. break;
  469. case E820_ACPI:
  470. printk("(ACPI data)n");
  471. break;
  472. case E820_NVS:
  473. printk("(ACPI NVS)n");
  474. break;
  475. default: printk("type %lun", e820.map[i].type);
  476. break;
  477. }
  478. }
  479. }
  481. /*
  482.  * Sanitize the BIOS e820 map.
  483.  *
  484.  * Some e820 responses include overlapping entries.  The following 
  485.  * replaces the original e820 map with a new one, removing overlaps.
  486.  *
  487.  */
  488. static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
  489. {
  490. struct change_member {
  491. struct e820entry *pbios; /* pointer to original bios entry */
  492. unsigned long long addr; /* address for this change point */
  493. };
  494. struct change_member change_point_list[2*E820MAX];
  495. struct change_member *change_point[2*E820MAX];
  496. struct e820entry *overlap_list[E820MAX];
  497. struct e820entry new_bios[E820MAX];
  498. struct change_member *change_tmp;
  499. unsigned long current_type, last_type;
  500. unsigned long long last_addr;
  501. int chgidx, still_changing;
  502. int overlap_entries;
  503. int new_bios_entry;
  504. int old_nr, new_nr;
  505. int i;
  507. /*
  508. Visually we're performing the following (1,2,3,4 = memory types)...
  510. Sample memory map (w/overlaps):
  511.    ____22__________________
  512.    ______________________4_
  513.    ____1111________________
  514.    _44_____________________
  515.    11111111________________
  516.    ____________________33__
  517.    ___________44___________
  518.    __________33333_________
  519.    ______________22________
  520.    ___________________2222_
  521.    _________111111111______
  522.    _____________________11_
  523.    _________________4______
  525. Sanitized equivalent (no overlap):
  526.    1_______________________
  527.    _44_____________________
  528.    ___1____________________
  529.    ____22__________________
  530.    ______11________________
  531.    _________1______________
  532.    __________3_____________
  533.    ___________44___________
  534.    _____________33_________
  535.    _______________2________
  536.    ________________1_______
  537.    _________________4______
  538.    ___________________2____
  539.    ____________________33__
  540.    ______________________4_
  541. */
  543. /* if there's only one memory region, don't bother */
  544. if (*pnr_map < 2)
  545. return -1;
  547. old_nr = *pnr_map;
  549. /* bail out if we find any unreasonable addresses in bios map */
  550. for (i=0; i<old_nr; i++)
  551. if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
  552. return -1;
  554. /* create pointers for initial change-point information (for sorting) */
  555. for (i=0; i < 2*old_nr; i++)
  556. change_point[i] = &change_point_list[i];
  558. /* record all known change-points (starting and ending addresses) */
  559. chgidx = 0;
  560. for (i=0; i < old_nr; i++) {
  561. change_point[chgidx]->addr = biosmap[i].addr;
  562. change_point[chgidx++]->pbios = &biosmap[i];
  563. change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
  564. change_point[chgidx++]->pbios = &biosmap[i];
  565. }
  567. /* sort change-point list by memory addresses (low -> high) */
  568. still_changing = 1;
  569. while (still_changing) {
  570. still_changing = 0;
  571. for (i=1; i < 2*old_nr; i++)  {
  572. /* if <current_addr> > <last_addr>, swap */
  573. /* or, if current=<start_addr> & last=<end_addr>, swap */
  574. if ((change_point[i]->addr < change_point[i-1]->addr) ||
  575. ((change_point[i]->addr == change_point[i-1]->addr) &&
  576.  (change_point[i]->addr == change_point[i]->pbios->addr) &&
  577.  (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
  578.    )
  579. {
  580. change_tmp = change_point[i];
  581. change_point[i] = change_point[i-1];
  582. change_point[i-1] = change_tmp;
  583. still_changing=1;
  584. }
  585. }
  586. }
  588. /* create a new bios memory map, removing overlaps */
  589. overlap_entries=0;  /* number of entries in the overlap table */
  590. new_bios_entry=0;  /* index for creating new bios map entries */
  591. last_type = 0;  /* start with undefined memory type */
  592. last_addr = 0;  /* start with 0 as last starting address */
  593. /* loop through change-points, determining affect on the new bios map */
  594. for (chgidx=0; chgidx < 2*old_nr; chgidx++)
  595. {
  596. /* keep track of all overlapping bios entries */
  597. if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
  598. {
  599. /* add map entry to overlap list (> 1 entry implies an overlap) */
  600. overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
  601. }
  602. else
  603. {
  604. /* remove entry from list (order independent, so swap with last) */
  605. for (i=0; i<overlap_entries; i++)
  606. {
  607. if (overlap_list[i] == change_point[chgidx]->pbios)
  608. overlap_list[i] = overlap_list[overlap_entries-1];
  609. }
  610. overlap_entries--;
  611. }
  612. /* if there are overlapping entries, decide which "type" to use */
  613. /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
  614. current_type = 0;
  615. for (i=0; i<overlap_entries; i++)
  616. if (overlap_list[i]->type > current_type)
  617. current_type = overlap_list[i]->type;
  618. /* continue building up new bios map based on this information */
  619. if (current_type != last_type) {
  620. if (last_type != 0)  {
  621. new_bios[new_bios_entry].size =
  622. change_point[chgidx]->addr - last_addr;
  623. /* move forward only if the new size was non-zero */
  624. if (new_bios[new_bios_entry].size != 0)
  625. if (++new_bios_entry >= E820MAX)
  626. break;  /* no more space left for new bios entries */
  627. }
  628. if (current_type != 0) {
  629. new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
  630. new_bios[new_bios_entry].type = current_type;
  631. last_addr=change_point[chgidx]->addr;
  632. }
  633. last_type = current_type;
  634. }
  635. }
  636. new_nr = new_bios_entry;   /* retain count for new bios entries */
  638. /* copy new bios mapping into original location */
  639. memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
  640. *pnr_map = new_nr;
  642. return 0;
  643. }
  645. /*
  646.  * Copy the BIOS e820 map into a safe place.
  647.  *
  648.  * Sanity-check it while we're at it..
  649.  *
  650.  * If we're lucky and live on a modern system, the setup code
  651.  * will have given us a memory map that we can use to properly
  652.  * set up memory.  If we aren't, we'll fake a memory map.
  653.  *
  654.  * We check to see that the memory map contains at least 2 elements
  655.  * before we'll use it, because the detection code in setup.S may
  656.  * not be perfect and most every PC known to man has two memory
  657.  * regions: one from 0 to 640k, and one from 1mb up.  (The IBM
  658.  * thinkpad 560x, for example, does not cooperate with the memory
  659.  * detection code.)
  660.  */
  661. static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
  662. {
  663. /* Only one memory region (or negative)? Ignore it */
  664. if (nr_map < 2)
  665. return -1;
  667. do {
  668. unsigned long long start = biosmap->addr;
  669. unsigned long long size = biosmap->size;
  670. unsigned long long end = start + size;
  671. unsigned long type = biosmap->type;
  673. /* Overflow in 64 bits? Ignore the memory map. */
  674. if (start > end)
  675. return -1;
  677. /*
  678.  * Some BIOSes claim RAM in the 640k - 1M region.
  679.  * Not right. Fix it up.
  680.  */
  681. if (type == E820_RAM) {
  682. if (start < 0x100000ULL && end > 0xA0000ULL) {
  683. if (start < 0xA0000ULL)
  684. add_memory_region(start, 0xA0000ULL-start, type);
  685. if (end <= 0x100000ULL)
  686. continue;
  687. start = 0x100000ULL;
  688. size = end - start;
  689. }
  690. }
  691. add_memory_region(start, size, type);
  692. } while (biosmap++,--nr_map);
  693. return 0;
  694. }
  696. /*
  697.  * Do NOT EVER look at the BIOS memory size location.
  698.  * It does not work on many machines.
  699.  */
  700. #define LOWMEMSIZE() (0x9f000)
  702. static void __init setup_memory_region(void)
  703. {
  704. char *who = "BIOS-e820";
  706. /*
  707.  * Try to copy the BIOS-supplied E820-map.
  708.  *
  709.  * Otherwise fake a memory map; one section from 0k->640k,
  710.  * the next section from 1mb->appropriate_mem_k
  711.  */
  712. sanitize_e820_map(E820_MAP, &E820_MAP_NR);
  713. if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
  714. unsigned long mem_size;
  716. /* compare results from other methods and take the greater */
  717. if (ALT_MEM_K < EXT_MEM_K) {
  718. mem_size = EXT_MEM_K;
  719. who = "BIOS-88";
  720. } else {
  721. mem_size = ALT_MEM_K;
  722. who = "BIOS-e801";
  723. }
  725. e820.nr_map = 0;
  726. add_memory_region(0, LOWMEMSIZE(), E820_RAM);
  727. add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
  728.    }
  729. printk(KERN_INFO "BIOS-provided physical RAM map:n");
  730. print_memory_map(who);
  731. } /* setup_memory_region */
  734. static void __init parse_cmdline_early (char ** cmdline_p)
  735. {
  736. char c = ' ', *to = command_line, *from = COMMAND_LINE;
  737. int len = 0;
  738. int userdef = 0;
  740. /* Save unparsed command line copy for /proc/cmdline */
  741. memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
  742. saved_command_line[COMMAND_LINE_SIZE-1] = '';
  744. for (;;) {
  745. if (c != ' ')
  746. goto nextchar;
  747. /*
  748.  * "mem=nopentium" disables the 4MB page tables.
  749.  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
  750.  * to <mem>, overriding the bios size.
  751.  * "mem=XXX[KkmM]@XXX[KkmM]" defines a memory region from
  752.  * <start> to <start>+<mem>, overriding the bios size.
  753.  */
  754. if (!memcmp(from, "mem=", 4)) {
  755. if (to != command_line)
  756. to--;
  757. if (!memcmp(from+4, "nopentium", 9)) {
  758. from += 9+4;
  759. clear_bit(X86_FEATURE_PSE, &boot_cpu_data.x86_capability);
  760. set_bit(X86_FEATURE_PSE, &disabled_x86_caps);
  761. } else if (!memcmp(from+4, "exactmap", 8)) {
  762. from += 8+4;
  763. e820.nr_map = 0;
  764. userdef = 1;
  765. } else {
  766. /* If the user specifies memory size, we
  767.  * limit the BIOS-provided memory map to
  768.  * that size. exactmap can be used to specify
  769.  * the exact map. mem=number can be used to
  770.  * trim the existing memory map.
  771.  */
  772. unsigned long long start_at, mem_size;
  773.  
  774. mem_size = memparse(from+4, &from);
  775. if (*from == '@') {
  776. start_at = memparse(from+1, &from);
  777. add_memory_region(start_at, mem_size, E820_RAM);
  778. } else {
  779. limit_regions(mem_size);
  780. userdef=1;
  781. }
  782. }
  783. }
  785. /* "noht" disables HyperThreading (2 logical cpus per Xeon) */
  786. else if (!memcmp(from, "noht", 4)) { 
  787. disable_x86_ht = 1;
  788. set_bit(X86_FEATURE_HT, disabled_x86_caps);
  789. }
  791. /* "acpismp=force" forces parsing and use of the ACPI SMP table */
  792. else if (!memcmp(from, "acpismp=force", 13))
  793. enable_acpi_smp_table = 1;
  795. /*
  796.  * highmem=size forces highmem to be exactly 'size' bytes.
  797.  * This works even on boxes that have no highmem otherwise.
  798.  * This also works to reduce highmem size on bigger boxes.
  799.  */
  800. else if (!memcmp(from, "highmem=", 8))
  801. highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
  802. nextchar:
  803. c = *(from++);
  804. if (!c)
  805. break;
  806. if (COMMAND_LINE_SIZE <= ++len)
  807. break;
  808. *(to++) = c;
  809. }
  810. *to = '';
  811. *cmdline_p = command_line;
  812. if (userdef) {
  813. printk(KERN_INFO "user-defined physical RAM map:n");
  814. print_memory_map("user");
  815. }
  816. }
  818. #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
  819. #define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
  820. #define PFN_PHYS(x) ((x) << PAGE_SHIFT)
  822. /*
  823.  * Reserved space for vmalloc and iomap - defined in asm/page.h
  824.  */
  825. #define MAXMEM_PFN PFN_DOWN(MAXMEM)
  826. #define MAX_NONPAE_PFN (1 << 20)
  828. /*
  829.  * Find the highest page frame number we have available
  830.  */
  831. static void __init find_max_pfn(void)
  832. {
  833. int i;
  835. max_pfn = 0;
  836. for (i = 0; i < e820.nr_map; i++) {
  837. unsigned long start, end;
  838. /* RAM? */
  839. if (e820.map[i].type != E820_RAM)
  840. continue;
  841. start = PFN_UP(e820.map[i].addr);
  842. end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
  843. if (start >= end)
  844. continue;
  845. if (end > max_pfn)
  846. max_pfn = end;
  847. }
  848. }
  850. /*
  851.  * Determine low and high memory ranges:
  852.  */
  853. static unsigned long __init find_max_low_pfn(void)
  854. {
  855. unsigned long max_low_pfn;
  857. max_low_pfn = max_pfn;
  858. if (max_low_pfn > MAXMEM_PFN) {
  859. if (highmem_pages == -1)
  860. highmem_pages = max_pfn - MAXMEM_PFN;
  861. if (highmem_pages + MAXMEM_PFN < max_pfn)
  862. max_pfn = MAXMEM_PFN + highmem_pages;
  863. if (highmem_pages + MAXMEM_PFN > max_pfn) {
  864. printk("only %luMB highmem pages available, ignoring highmem size of %uMB.n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
  865. highmem_pages = 0;
  866. }
  867. max_low_pfn = MAXMEM_PFN;
  868. #ifndef CONFIG_HIGHMEM
  869. /* Maximum memory usable is what is directly addressable */
  870. printk(KERN_WARNING "Warning only %ldMB will be used.n",
  871. MAXMEM>>20);
  872. if (max_pfn > MAX_NONPAE_PFN)
  873. printk(KERN_WARNING "Use a PAE enabled kernel.n");
  874. else
  875. printk(KERN_WARNING "Use a HIGHMEM enabled kernel.n");
  876. #else /* !CONFIG_HIGHMEM */
  877. #ifndef CONFIG_X86_PAE
  878. if (max_pfn > MAX_NONPAE_PFN) {
  879. max_pfn = MAX_NONPAE_PFN;
  880. printk(KERN_WARNING "Warning only 4GB will be used.n");
  881. printk(KERN_WARNING "Use a PAE enabled kernel.n");
  882. }
  883. #endif /* !CONFIG_X86_PAE */
  884. #endif /* !CONFIG_HIGHMEM */
  885. } else {
  886. if (highmem_pages == -1)
  887. highmem_pages = 0;
  888. #if CONFIG_HIGHMEM
  889. if (highmem_pages >= max_pfn) {
  890. printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
  891. highmem_pages = 0;
  892. }
  893. if (highmem_pages) {
  894. if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
  895. printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.n", pages_to_mb(highmem_pages));
  896. highmem_pages = 0;
  897. }
  898. max_low_pfn -= highmem_pages;
  899. }
  900. #else
  901. if (highmem_pages)
  902. printk(KERN_ERR "ignoring highmem size on non-highmem kernel!n");
  903. #endif
  904. }
  906. return max_low_pfn;
  907. }
  909. /*
  910.  * Register fully available low RAM pages with the bootmem allocator.
  911.  */
  912. static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
  913. {
  914. int i;
  916. for (i = 0; i < e820.nr_map; i++) {
  917. unsigned long curr_pfn, last_pfn, size;
  918. /*
  919.  * Reserve usable low memory
  920.  */
  921. if (e820.map[i].type != E820_RAM)
  922. continue;
  923. /*
  924.  * We are rounding up the start address of usable memory:
  925.  */
  926. curr_pfn = PFN_UP(e820.map[i].addr);
  927. if (curr_pfn >= max_low_pfn)
  928. continue;
  929. /*
  930.  * ... and at the end of the usable range downwards:
  931.  */
  932. last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
  934. if (last_pfn > max_low_pfn)
  935. last_pfn = max_low_pfn;
  937. /*
  938.  * .. finally, did all the rounding and playing
  939.  * around just make the area go away?
  940.  */
  941. if (last_pfn <= curr_pfn)
  942. continue;
  944. size = last_pfn - curr_pfn;
  945. free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
  946. }
  947. }
  949. static unsigned long __init setup_memory(void)
  950. {
  951. unsigned long bootmap_size, start_pfn, max_low_pfn;
  953. /*
  954.  * partially used pages are not usable - thus
  955.  * we are rounding upwards:
  956.  */
  957. start_pfn = PFN_UP(__pa(&_end));
  959. find_max_pfn();
  961. max_low_pfn = find_max_low_pfn();
  963. #ifdef CONFIG_HIGHMEM
  964. highstart_pfn = highend_pfn = max_pfn;
  965. if (max_pfn > max_low_pfn) {
  966. highstart_pfn = max_low_pfn;
  967. }
  968. printk(KERN_NOTICE "%ldMB HIGHMEM available.n",
  969. pages_to_mb(highend_pfn - highstart_pfn));
  970. #endif
  971. printk(KERN_NOTICE "%ldMB LOWMEM available.n",
  972. pages_to_mb(max_low_pfn));
  973. /*
  974.  * Initialize the boot-time allocator (with low memory only):
  975.  */
  976. bootmap_size = init_bootmem(start_pfn, max_low_pfn);
  978. register_bootmem_low_pages(max_low_pfn);
  980. /*
  981.  * Reserve the bootmem bitmap itself as well. We do this in two
  982.  * steps (first step was init_bootmem()) because this catches
  983.  * the (very unlikely) case of us accidentally initializing the
  984.  * bootmem allocator with an invalid RAM area.
  985.  */
  986. reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(start_pfn) +
  987.  bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
  989. /*
  990.  * reserve physical page 0 - it's a special BIOS page on many boxes,
  991.  * enabling clean reboots, SMP operation, laptop functions.
  992.  */
  993. reserve_bootmem(0, PAGE_SIZE);
  995. #ifdef CONFIG_SMP
  996. /*
  997.  * But first pinch a few for the stack/trampoline stuff
  998.  * FIXME: Don't need the extra page at 4K, but need to fix
  999.  * trampoline before removing it. (see the GDT stuff)
  1000.  */
  1001. reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
  1002. #endif
  1004. #ifdef CONFIG_X86_LOCAL_APIC
  1005. /*
  1006.  * Find and reserve possible boot-time SMP configuration:
  1007.  */
  1008. find_smp_config();
  1009. #endif
  1010. #ifdef CONFIG_BLK_DEV_INITRD
  1011. if (LOADER_TYPE && INITRD_START) {
  1012. if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
  1013. reserve_bootmem(INITRD_START, INITRD_SIZE);
  1014. initrd_start =
  1015. INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
  1016. initrd_end = initrd_start+INITRD_SIZE;
  1017. }
  1018. else {
  1019. printk(KERN_ERR "initrd extends beyond end of memory "
  1020.     "(0x%08lx > 0x%08lx)ndisabling initrdn",
  1021.     INITRD_START + INITRD_SIZE,
  1022.     max_low_pfn << PAGE_SHIFT);
  1023. initrd_start = 0;
  1024. }
  1025. }
  1026. #endif
  1028. return max_low_pfn;
  1029. }
  1030.  
  1031. /*
  1032.  * Request address space for all standard RAM and ROM resources
  1033.  * and also for regions reported as reserved by the e820.
  1034.  */
  1035. static void __init register_memory(unsigned long max_low_pfn)
  1036. {
  1037. unsigned long low_mem_size;
  1038. int i;
  1040. probe_roms();
  1041. for (i = 0; i < e820.nr_map; i++) {
  1042. struct resource *res;
  1043. if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
  1044. continue;
  1045. res = alloc_bootmem_low(sizeof(struct resource));
  1046. switch (e820.map[i].type) {
  1047. case E820_RAM: res->name = "System RAM"; break;
  1048. case E820_ACPI: res->name = "ACPI Tables"; break;
  1049. case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
  1050. default: res->name = "reserved";
  1051. }
  1052. res->start = e820.map[i].addr;
  1053. res->end = res->start + e820.map[i].size - 1;
  1054. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  1055. request_resource(&iomem_resource, res);
  1056. if (e820.map[i].type == E820_RAM) {
  1057. /*
  1058.  *  We dont't know which RAM region contains kernel data,
  1059.  *  so we try it repeatedly and let the resource manager
  1060.  *  test it.
  1061.  */
  1062. request_resource(res, &code_resource);
  1063. request_resource(res, &data_resource);
  1064. }
  1065. }
  1066. request_resource(&iomem_resource, &vram_resource);
  1068. /* request I/O space for devices used on all i[345]86 PCs */
  1069. for (i = 0; i < STANDARD_IO_RESOURCES; i++)
  1070. request_resource(&ioport_resource, standard_io_resources+i);
  1072. /* Tell the PCI layer not to allocate too close to the RAM area.. */
  1073. low_mem_size = ((max_low_pfn << PAGE_SHIFT) + 0xfffff) & ~0xfffff;
  1074. if (low_mem_size > pci_mem_start)
  1075. pci_mem_start = low_mem_size;
  1076. }
  1078. void __init setup_arch(char **cmdline_p)
  1079. {
  1080. unsigned long max_low_pfn;
  1082. #ifdef CONFIG_VISWS
  1083. visws_get_board_type_and_rev();
  1084. #endif
  1086. #ifndef CONFIG_HIGHIO
  1087. blk_nohighio = 1;
  1088. #endif
  1090.   ROOT_DEV = to_kdev_t(ORIG_ROOT_DEV);
  1091.   drive_info = DRIVE_INFO;
  1092.   screen_info = SCREEN_INFO;
  1093. apm_info.bios = APM_BIOS_INFO;
  1094. if( SYS_DESC_TABLE.length != 0 ) {
  1095. MCA_bus = SYS_DESC_TABLE.table[3] &0x2;
  1096. machine_id = SYS_DESC_TABLE.table[0];
  1097. machine_submodel_id = SYS_DESC_TABLE.table[1];
  1098. BIOS_revision = SYS_DESC_TABLE.table[2];
  1099. }
  1100. aux_device_present = AUX_DEVICE_INFO;
  1102. #ifdef CONFIG_BLK_DEV_RAM
  1103. rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
  1104. rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
  1105. rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
  1106. #endif
  1107. setup_memory_region();
  1109. if (!MOUNT_ROOT_RDONLY)
  1110. root_mountflags &= ~MS_RDONLY;
  1111. init_mm.start_code = (unsigned long) &_text;
  1112. init_mm.end_code = (unsigned long) &_etext;
  1113. init_mm.end_data = (unsigned long) &_edata;
  1114. init_mm.brk = (unsigned long) &_end;
  1116. code_resource.start = virt_to_bus(&_text);
  1117. code_resource.end = virt_to_bus(&_etext)-1;
  1118. data_resource.start = virt_to_bus(&_etext);
  1119. data_resource.end = virt_to_bus(&_edata)-1;
  1121. parse_cmdline_early(cmdline_p);
  1123. max_low_pfn = setup_memory();
  1125. /*
  1126.  * If enable_acpi_smp_table and HT feature present, acpitable.c
  1127.  * will find all logical cpus despite disable_x86_ht: so if both
  1128.  * "noht" and "acpismp=force" are specified, let "noht" override
  1129.  * "acpismp=force" cleanly.  Why retain "acpismp=force"? because
  1130.  * parsing ACPI SMP table might prove useful on some non-HT cpu.
  1131.  */
  1132. if (disable_x86_ht) {
  1133. clear_bit(X86_FEATURE_HT, &boot_cpu_data.x86_capability[0]);
  1134. set_bit(X86_FEATURE_HT, disabled_x86_caps);
  1135. enable_acpi_smp_table = 0;
  1136. }
  1137. if (test_bit(X86_FEATURE_HT, &boot_cpu_data.x86_capability[0]))
  1138. enable_acpi_smp_table = 1;
  1141. /*
  1142.  * NOTE: before this point _nobody_ is allowed to allocate
  1143.  * any memory using the bootmem allocator.
  1144.  */
  1146. #ifdef CONFIG_SMP
  1147. smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
  1148. #endif
  1149. paging_init();
  1150. #ifdef CONFIG_X86_LOCAL_APIC
  1151. /*
  1152.  * get boot-time SMP configuration:
  1153.  */
  1154. if (smp_found_config)
  1155. get_smp_config();
  1156. #endif
  1158. register_memory(max_low_pfn);
  1160. #ifdef CONFIG_VT
  1161. #if defined(CONFIG_VGA_CONSOLE)
  1162. conswitchp = &vga_con;
  1163. #elif defined(CONFIG_DUMMY_CONSOLE)
  1164. conswitchp = &dummy_con;
  1165. #endif
  1166. #endif
  1167. dmi_scan_machine();
  1168. }
  1170. static int cachesize_override __initdata = -1;
  1171. static int __init cachesize_setup(char *str)
  1172. {
  1173. get_option (&str, &cachesize_override);
  1174. return 1;
  1175. }
  1176. __setup("cachesize=", cachesize_setup);
  1179. #ifndef CONFIG_X86_TSC
  1180. static int tsc_disable __initdata = 0;
  1182. static int __init notsc_setup(char *str)
  1183. {
  1184. tsc_disable = 1;
  1185. return 1;
  1186. }
  1187. #else
  1188. static int __init notsc_setup(char *str)
  1189. {
  1190. printk("notsc: Kernel compiled with CONFIG_X86_TSC, cannot disable TSC.n");
  1191. return 1;
  1192. }
  1193. #endif
  1194. __setup("notsc", notsc_setup);
  1196. static int __init highio_setup(char *str)
  1197. {
  1198. printk("i386: disabling HIGHMEM block I/On");
  1199. blk_nohighio = 1;
  1200. return 1;
  1201. }
  1202. __setup("nohighio", highio_setup);
  1204. static int __init get_model_name(struct cpuinfo_x86 *c)
  1205. {
  1206. unsigned int *v;
  1207. char *p, *q;
  1209. if (cpuid_eax(0x80000000) < 0x80000004)
  1210. return 0;
  1212. v = (unsigned int *) c->x86_model_id;
  1213. cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
  1214. cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
  1215. cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
  1216. c->x86_model_id[48] = 0;
  1218. /* Intel chips right-justify this string for some dumb reason;
  1219.    undo that brain damage */
  1220. p = q = &c->x86_model_id[0];
  1221. while ( *p == ' ' )
  1222.      p++;
  1223. if ( p != q ) {
  1224.      while ( *p )
  1225.   *q++ = *p++;
  1226.      while ( q <= &c->x86_model_id[48] )
  1227.   *q++ = ''; /* Zero-pad the rest */
  1228. }
  1230. return 1;
  1231. }
  1234. static void __init display_cacheinfo(struct cpuinfo_x86 *c)
  1235. {
  1236. unsigned int n, dummy, ecx, edx, l2size;
  1238. n = cpuid_eax(0x80000000);
  1240. if (n >= 0x80000005) {
  1241. cpuid(0x80000005, &dummy, &dummy, &ecx, &edx);
  1242. printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)n",
  1243. edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
  1244. c->x86_cache_size=(ecx>>24)+(edx>>24);
  1245. }
  1247. if (n < 0x80000006) /* Some chips just has a large L1. */
  1248. return;
  1250. ecx = cpuid_ecx(0x80000006);
  1251. l2size = ecx >> 16;
  1253. /* AMD errata T13 (order #21922) */
  1254. if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) {
  1255. if (c->x86_model == 3 && c->x86_mask == 0) /* Duron Rev A0 */
  1256. l2size = 64;
  1257. if (c->x86_model == 4 &&
  1258. (c->x86_mask==0 || c->x86_mask==1)) /* Tbird rev A1/A2 */
  1259. l2size = 256;
  1260. }
  1262. /* Intel PIII Tualatin. This comes in two flavours.
  1263.  * One has 256kb of cache, the other 512. We have no way
  1264.  * to determine which, so we use a boottime override
  1265.  * for the 512kb model, and assume 256 otherwise.
  1266.  */
  1267. if ((c->x86_vendor == X86_VENDOR_INTEL) && (c->x86 == 6) &&
  1268. (c->x86_model == 11) && (l2size == 0))
  1269. l2size = 256;
  1271. /* VIA C3 CPUs (670-68F) need further shifting. */
  1272. if (c->x86_vendor == X86_VENDOR_CENTAUR && (c->x86 == 6) &&
  1273. ((c->x86_model == 7) || (c->x86_model == 8))) {
  1274. l2size = l2size >> 8;
  1275. }
  1277. /* Allow user to override all this if necessary. */
  1278. if (cachesize_override != -1)
  1279. l2size = cachesize_override;
  1281. if ( l2size == 0 )
  1282. return; /* Again, no L2 cache is possible */
  1284. c->x86_cache_size = l2size;
  1286. printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)n",
  1287.        l2size, ecx & 0xFF);
  1288. }
  1290. /*
  1291.  * B step AMD K6 before B 9730xxxx have hardware bugs that can cause
  1292.  * misexecution of code under Linux. Owners of such processors should
  1293.  * contact AMD for precise details and a CPU swap.
  1294.  *
  1295.  * See http://www.multimania.com/poulot/k6bug.html
  1296.  * http://www.amd.com/K6/k6docs/revgd.html
  1297.  *
  1298.  * The following test is erm.. interesting. AMD neglected to up
  1299.  * the chip setting when fixing the bug but they also tweaked some
  1300.  * performance at the same time..
  1301.  */
  1302.  
  1303. extern void vide(void);
  1304. __asm__(".align 4nvide: ret");
  1306. static int __init init_amd(struct cpuinfo_x86 *c)
  1307. {
  1308. u32 l, h;
  1309. int mbytes = max_mapnr >> (20-PAGE_SHIFT);
  1310. int r;
  1312. /*
  1313.  * FIXME: We should handle the K5 here. Set up the write
  1314.  * range and also turn on MSR 83 bits 4 and 31 (write alloc,
  1315.  * no bus pipeline)
  1316.  */
  1318. /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
  1319.    3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
  1320. clear_bit(0*32+31, &c->x86_capability);
  1322. r = get_model_name(c);
  1324. switch(c->x86)
  1325. {
  1326. case 5:
  1327. if( c->x86_model < 6 )
  1328. {
  1329. /* Based on AMD doc 20734R - June 2000 */
  1330. if ( c->x86_model == 0 ) {
  1331. clear_bit(X86_FEATURE_APIC, &c->x86_capability);
  1332. set_bit(X86_FEATURE_PGE, &c->x86_capability);
  1333. }
  1334. break;
  1335. }
  1337. if ( c->x86_model == 6 && c->x86_mask == 1 ) {
  1338. const int K6_BUG_LOOP = 1000000;
  1339. int n;
  1340. void (*f_vide)(void);
  1341. unsigned long d, d2;
  1343. printk(KERN_INFO "AMD K6 stepping B detected - ");
  1345. /*
  1346.  * It looks like AMD fixed the 2.6.2 bug and improved indirect 
  1347.  * calls at the same time.
  1348.  */
  1350. n = K6_BUG_LOOP;
  1351. f_vide = vide;
  1352. rdtscl(d);
  1353. while (n--) 
  1354. f_vide();
  1355. rdtscl(d2);
  1356. d = d2-d;
  1358. /* Knock these two lines out if it debugs out ok */
  1359. printk(KERN_INFO "K6 BUG %ld %d (Report these if test report is incorrect)n", d, 20*K6_BUG_LOOP);
  1360. printk(KERN_INFO "AMD K6 stepping B detected - ");
  1361. /* -- cut here -- */
  1362. if (d > 20*K6_BUG_LOOP) 
  1363. printk("system stability may be impaired when more than 32 MB are used.n");
  1364. else 
  1365. printk("probably OK (after B9730xxxx).n");
  1366. printk(KERN_INFO "Please see http://www.mygale.com/~poulot/k6bug.htmln");
  1367. }
  1369. /* K6 with old style WHCR */
  1370. if (c->x86_model < 8 ||
  1371.    (c->x86_model== 8 && c->x86_mask < 8)) {
  1372. /* We can only write allocate on the low 508Mb */
  1373. if(mbytes>508)
  1374. mbytes=508;
  1376. rdmsr(MSR_K6_WHCR, l, h);
  1377. if ((l&0x0000FFFF)==0) {
  1378. unsigned long flags;
  1379. l=(1<<0)|((mbytes/4)<<1);
  1380. local_irq_save(flags);
  1381. wbinvd();
  1382. wrmsr(MSR_K6_WHCR, l, h);
  1383. local_irq_restore(flags);
  1384. printk(KERN_INFO "Enabling old style K6 write allocation for %d Mbn",
  1385. mbytes);
  1386. }
  1387. break;
  1388. }
  1390. if ((c->x86_model == 8 && c->x86_mask >7) ||
  1391.      c->x86_model == 9 || c->x86_model == 13) {
  1392. /* The more serious chips .. */
  1394. if(mbytes>4092)
  1395. mbytes=4092;
  1397. rdmsr(MSR_K6_WHCR, l, h);
  1398. if ((l&0xFFFF0000)==0) {
  1399. unsigned long flags;
  1400. l=((mbytes>>2)<<22)|(1<<16);
  1401. local_irq_save(flags);
  1402. wbinvd();
  1403. wrmsr(MSR_K6_WHCR, l, h);
  1404. local_irq_restore(flags);
  1405. printk(KERN_INFO "Enabling new style K6 write allocation for %d Mbn",
  1406. mbytes);
  1407. }
  1409. /*  Set MTRR capability flag if appropriate */
  1410. if (c->x86_model == 13 || c->x86_model == 9 ||
  1411.    (c->x86_model == 8 && c->x86_mask >= 8))
  1412. set_bit(X86_FEATURE_K6_MTRR, &c->x86_capability);
  1413. break;
  1414. }
  1415. break;
  1417. case 6: /* An Athlon/Duron */
  1418.  
  1419. /* Bit 15 of Athlon specific MSR 15, needs to be 0
  1420.    * to enable SSE on Palomino/Morgan CPU's.
  1421.  * If the BIOS didn't enable it already, enable it
  1422.  * here.
  1423.  */
  1424. if (c->x86_model == 6 || c->x86_model == 7) {
  1425. if (!test_bit(X86_FEATURE_XMM,
  1426.       &c->x86_capability)) {
  1427. printk(KERN_INFO
  1428.        "Enabling Disabled K7/SSE Support...n");
  1429. rdmsr(MSR_K7_HWCR, l, h);
  1430. l &= ~0x00008000;
  1431. wrmsr(MSR_K7_HWCR, l, h);
  1432. set_bit(X86_FEATURE_XMM,
  1433.                                                 &c->x86_capability);
  1434. }
  1435. }
  1436. break;
  1438. }
  1440. display_cacheinfo(c);
  1441. return r;
  1442. }
  1444. /*
  1445.  * Read NSC/Cyrix DEVID registers (DIR) to get more detailed info. about the CPU
  1446.  */
  1447. static void __init do_cyrix_devid(unsigned char *dir0, unsigned char *dir1)
  1448. {
  1449. unsigned char ccr2, ccr3;
  1450. unsigned long flags;
  1452. /* we test for DEVID by checking whether CCR3 is writable */
  1453. local_irq_save(flags);
  1454. ccr3 = getCx86(CX86_CCR3);
  1455. setCx86(CX86_CCR3, ccr3 ^ 0x80);
  1456. getCx86(0xc0);   /* dummy to change bus */
  1458. if (getCx86(CX86_CCR3) == ccr3) {       /* no DEVID regs. */
  1459. ccr2 = getCx86(CX86_CCR2);
  1460. setCx86(CX86_CCR2, ccr2 ^ 0x04);
  1461. getCx86(0xc0);  /* dummy */
  1463. if (getCx86(CX86_CCR2) == ccr2) /* old Cx486SLC/DLC */
  1464. *dir0 = 0xfd;
  1465. else {                          /* Cx486S A step */
  1466. setCx86(CX86_CCR2, ccr2);
  1467. *dir0 = 0xfe;
  1468. }
  1469. }
  1470. else {
  1471. setCx86(CX86_CCR3, ccr3);  /* restore CCR3 */
  1473. /* read DIR0 and DIR1 CPU registers */
  1474. *dir0 = getCx86(CX86_DIR0);
  1475. *dir1 = getCx86(CX86_DIR1);
  1476. }
  1477. local_irq_restore(flags);
  1478. }
  1480. /*
  1481.  * Cx86_dir0_msb is a HACK needed by check_cx686_cpuid/slop in bugs.h in
  1482.  * order to identify the Cyrix CPU model after we're out of setup.c
  1483.  *
  1484.  * Actually since bugs.h doesn't even reference this perhaps someone should
  1485.  * fix the documentation ???
  1486.  */
  1487. static unsigned char Cx86_dir0_msb __initdata = 0;
  1489. static char Cx86_model[][9] __initdata = {
  1490. "Cx486", "Cx486", "5x86 ", "6x86", "MediaGX ", "6x86MX ",
  1491. "M II ", "Unknown"
  1492. };
  1493. static char Cx486_name[][5] __initdata = {
  1494. "SLC", "DLC", "SLC2", "DLC2", "SRx", "DRx",
  1495. "SRx2", "DRx2"
  1496. };
  1497. static char Cx486S_name[][4] __initdata = {
  1498. "S", "S2", "Se", "S2e"
  1499. };
  1500. static char Cx486D_name[][4] __initdata = {
  1501. "DX", "DX2", "?", "?", "?", "DX4"
  1502. };
  1503. static char Cx86_cb[] __initdata = "?.5x Core/Bus Clock";
  1504. static char cyrix_model_mult1[] __initdata = "12??43";
  1505. static char cyrix_model_mult2[] __initdata = "12233445";
  1507. /*
  1508.  * Reset the slow-loop (SLOP) bit on the 686(L) which is set by some old
  1509.  * BIOSes for compatability with DOS games.  This makes the udelay loop
  1510.  * work correctly, and improves performance.
  1511.  *
  1512.  * FIXME: our newer udelay uses the tsc. We dont need to frob with SLOP
  1513.  */
  1515. extern void calibrate_delay(void) __init;
  1517. static void __init check_cx686_slop(struct cpuinfo_x86 *c)
  1518. {
  1519. unsigned long flags;
  1521. if (Cx86_dir0_msb == 3) {
  1522. unsigned char ccr3, ccr5;
  1524. local_irq_save(flags);
  1525. ccr3 = getCx86(CX86_CCR3);
  1526. setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
  1527. ccr5 = getCx86(CX86_CCR5);
  1528. if (ccr5 & 2)
  1529. setCx86(CX86_CCR5, ccr5 & 0xfd);  /* reset SLOP */
  1530. setCx86(CX86_CCR3, ccr3);                 /* disable MAPEN */
  1531. local_irq_restore(flags);
  1533. if (ccr5 & 2) { /* possible wrong calibration done */
  1534. printk(KERN_INFO "Recalibrating delay loop with SLOP bit resetn");
  1535. calibrate_delay();
  1536. c->loops_per_jiffy = loops_per_jiffy;
  1537. }
  1538. }
  1539. }
  1541. static void __init init_cyrix(struct cpuinfo_x86 *c)
  1542. {
  1543. unsigned char dir0, dir0_msn, dir0_lsn, dir1 = 0;
  1544. char *buf = c->x86_model_id;
  1545. const char *p = NULL;
  1547. /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
  1548.    3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
  1549. clear_bit(0*32+31, &c->x86_capability);
  1551. /* Cyrix used bit 24 in extended (AMD) CPUID for Cyrix MMX extensions */
  1552. if ( test_bit(1*32+24, &c->x86_capability) ) {
  1553. clear_bit(1*32+24, &c->x86_capability);
  1554. set_bit(X86_FEATURE_CXMMX, &c->x86_capability);
  1555. }
  1557. do_cyrix_devid(&dir0, &dir1);
  1559. check_cx686_slop(c);
  1561. Cx86_dir0_msb = dir0_msn = dir0 >> 4; /* identifies CPU "family"   */
  1562. dir0_lsn = dir0 & 0xf;                /* model or clock multiplier */
  1564. /* common case step number/rev -- exceptions handled below */
  1565. c->x86_model = (dir1 >> 4) + 1;
  1566. c->x86_mask = dir1 & 0xf;
  1568. /* Now cook; the original recipe is by Channing Corn, from Cyrix.
  1569.  * We do the same thing for each generation: we work out
  1570.  * the model, multiplier and stepping.  Black magic included,
  1571.  * to make the silicon step/rev numbers match the printed ones.
  1572.  */
  1573.  
  1574. switch (dir0_msn) {
  1575. unsigned char tmp;
  1577. case 0: /* Cx486SLC/DLC/SRx/DRx */
  1578. p = Cx486_name[dir0_lsn & 7];
  1579. break;
  1581. case 1: /* Cx486S/DX/DX2/DX4 */
  1582. p = (dir0_lsn & 8) ? Cx486D_name[dir0_lsn & 5]
  1583. : Cx486S_name[dir0_lsn & 3];
  1584. break;
  1586. case 2: /* 5x86 */
  1587. Cx86_cb[2] = cyrix_model_mult1[dir0_lsn & 5];
  1588. p = Cx86_cb+2;
  1589. break;
  1591. case 3: /* 6x86/6x86L */
  1592. Cx86_cb[1] = ' ';
  1593. Cx86_cb[2] = cyrix_model_mult1[dir0_lsn & 5];
  1594. if (dir1 > 0x21) { /* 686L */
  1595. Cx86_cb[0] = 'L';
  1596. p = Cx86_cb;
  1597. (c->x86_model)++;
  1598. } else             /* 686 */
  1599. p = Cx86_cb+1;
  1600. /* Emulate MTRRs using Cyrix's ARRs. */
  1601. set_bit(X86_FEATURE_CYRIX_ARR, &c->x86_capability);
  1602. /* 6x86's contain this bug */
  1603. c->coma_bug = 1;
  1604. break;
  1606. case 4: /* MediaGX/GXm */
  1607. #ifdef CONFIG_PCI
  1608. /* It isnt really a PCI quirk directly, but the cure is the
  1609.    same. The MediaGX has deep magic SMM stuff that handles the
  1610.    SB emulation. It thows away the fifo on disable_dma() which
  1611.    is wrong and ruins the audio. 
  1612.                    
  1613.    Bug2: VSA1 has a wrap bug so that using maximum sized DMA 
  1614.    causes bad things. According to NatSemi VSA2 has another
  1615.    bug to do with 'hlt'. I've not seen any boards using VSA2
  1616.    and X doesn't seem to support it either so who cares 8).
  1617.    VSA1 we work around however.
  1618. */
  1620. printk(KERN_INFO "Working around Cyrix MediaGX virtual DMA bugs.n");
  1621. isa_dma_bridge_buggy = 2;
  1622. #endif
  1623. c->x86_cache_size=16; /* Yep 16K integrated cache thats it */
  1625. /* GXm supports extended cpuid levels 'ala' AMD */
  1626. if (c->cpuid_level == 2) {
  1627. get_model_name(c);  /* get CPU marketing name */
  1628. /*
  1629.    * The 5510/5520 companion chips have a funky PIT
  1630.  * that breaks the TSC synchronizing, so turn it off
  1631.  */
  1632. if(pci_find_device(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510, NULL) ||
  1633.    pci_find_device(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520, NULL))
  1634. clear_bit(X86_FEATURE_TSC, c->x86_capability);
  1635. return;
  1636. }
  1637. else {  /* MediaGX */
  1638. Cx86_cb[2] = (dir0_lsn & 1) ? '3' : '4';
  1639. p = Cx86_cb+2;
  1640. c->x86_model = (dir1 & 0x20) ? 1 : 2;
  1641. if(pci_find_device(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510, NULL) ||
  1642.    pci_find_device(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520, NULL))
  1643. clear_bit(X86_FEATURE_TSC, &c->x86_capability);
  1644. }
  1645. break;
  1647.         case 5: /* 6x86MX/M II */
  1648. if (dir1 > 7)
  1649. {
  1650. dir0_msn++;  /* M II */
  1651. /* Enable MMX extensions (App note 108) */
  1652. setCx86(CX86_CCR7, getCx86(CX86_CCR7)|1);
  1653. }
  1654. else
  1655. {
  1656. c->coma_bug = 1;      /* 6x86MX, it has the bug. */
  1657. }
  1658. tmp = (!(dir0_lsn & 7) || dir0_lsn & 1) ? 2 : 0;
  1659. Cx86_cb[tmp] = cyrix_model_mult2[dir0_lsn & 7];
  1660. p = Cx86_cb+tmp;
  1661.          if (((dir1 & 0x0f) > 4) || ((dir1 & 0xf0) == 0x20))
  1662. (c->x86_model)++;
  1663. /* Emulate MTRRs using Cyrix's ARRs. */
  1664. set_bit(X86_FEATURE_CYRIX_ARR, &c->x86_capability);
  1665. break;
  1667. case 0xf:  /* Cyrix 486 without DEVID registers */
  1668. switch (dir0_lsn) {
  1669. case 0xd:  /* either a 486SLC or DLC w/o DEVID */
  1670. dir0_msn = 0;
  1671. p = Cx486_name[(c->hard_math) ? 1 : 0];
  1672. break;
  1674. case 0xe:  /* a 486S A step */
  1675. dir0_msn = 0;
  1676. p = Cx486S_name[0];
  1677. break;
  1678. }
  1679. break;
  1681. default:  /* unknown (shouldn't happen, we know everyone ;-) */
  1682. dir0_msn = 7;
  1683. break;
  1684. }
  1685. strcpy(buf, Cx86_model[dir0_msn & 7]);
  1686. if (p) strcat(buf, p);
  1687. return;
  1688. }
  1690. #ifdef CONFIG_X86_OOSTORE
  1692. static u32 __init power2(u32 x)
  1693. {
  1694. u32 s=1;
  1695. while(s<=x)
  1696. s<<=1;
  1697. return s>>=1;
  1698. }
  1700. /*
  1701.  * Set up an actual MCR
  1702.  */
  1703.  
  1704. static void __init winchip_mcr_insert(int reg, u32 base, u32 size, int key)
  1705. {
  1706. u32 lo, hi;
  1708. hi = base & ~0xFFF;
  1709. lo = ~(size-1); /* Size is a power of 2 so this makes a mask */
  1710. lo &= ~0xFFF; /* Remove the ctrl value bits */
  1711. lo |= key; /* Attribute we wish to set */
  1712. wrmsr(reg+MSR_IDT_MCR0, lo, hi);
  1713. mtrr_centaur_report_mcr(reg, lo, hi); /* Tell the mtrr driver */
  1714. }
  1716. /*
  1717.  * Figure what we can cover with MCR's
  1718.  *
  1719.  * Shortcut: We know you can't put 4Gig of RAM on a winchip
  1720.  */
  1722. static u32 __init ramtop(void) /* 16388 */
  1723. {
  1724. int i;
  1725. u32 top = 0;
  1726. u32 clip = 0xFFFFFFFFUL;
  1728. for (i = 0; i < e820.nr_map; i++) {
  1729. unsigned long start, end;
  1731. if (e820.map[i].addr > 0xFFFFFFFFUL)
  1732. continue;
  1733. /*
  1734.  * Don't MCR over reserved space. Ignore the ISA hole
  1735.  * we frob around that catastrophy already
  1736.  */
  1737.  
  1738. if (e820.map[i].type == E820_RESERVED)
  1739. {
  1740. if(e820.map[i].addr >= 0x100000UL && e820.map[i].addr < clip)
  1741. clip = e820.map[i].addr;
  1742. continue;
  1743. }
  1744. start = e820.map[i].addr;
  1745. end = e820.map[i].addr + e820.map[i].size;
  1746. if (start >= end)
  1747. continue;
  1748. if (end > top)
  1749. top = end;
  1750. }
  1751. /* Everything below 'top' should be RAM except for the ISA hole.
  1752.    Because of the limited MCR's we want to map NV/ACPI into our
  1753.    MCR range for gunk in RAM 
  1754.    
  1755.    Clip might cause us to MCR insufficient RAM but that is an
  1756.    acceptable failure mode and should only bite obscure boxes with
  1757.    a VESA hole at 15Mb
  1758.    
  1759.    The second case Clip sometimes kicks in is when the EBDA is marked
  1760.    as reserved. Again we fail safe with reasonable results
  1761. */
  1763. if(top>clip)
  1764. top=clip;
  1766. return top;
  1767. }
  1769. /*
  1770.  * Compute a set of MCR's to give maximum coverage
  1771.  */
  1773. static int __init winchip_mcr_compute(int nr, int key)
  1774. {
  1775. u32 mem = ramtop();
  1776. u32 root = power2(mem);
  1777. u32 base = root;
  1778. u32 top = root;
  1779. u32 floor = 0;
  1780. int ct = 0;
  1782. while(ct<nr)
  1783. {
  1784. u32 fspace = 0;
  1786. /*
  1787.  * Find the largest block we will fill going upwards
  1788.  */
  1790. u32 high = power2(mem-top);
  1792. /*
  1793.  * Find the largest block we will fill going downwards
  1794.  */
  1796. u32 low = base/2;
  1798. /*
  1799.  * Don't fill below 1Mb going downwards as there
  1800.  * is an ISA hole in the way.
  1801.  */
  1802.  
  1803. if(base <= 1024*1024)
  1804. low = 0;
  1806. /*
  1807.  * See how much space we could cover by filling below
  1808.  * the ISA hole
  1809.  */
  1810.  
  1811. if(floor == 0)
  1812. fspace = 512*1024;
  1813. else if(floor ==512*1024)
  1814. fspace = 128*1024;
  1816. /* And forget ROM space */
  1818. /*
  1819.  * Now install the largest coverage we get
  1820.  */
  1821.  
  1822. if(fspace > high && fspace > low)
  1823. {
  1824. winchip_mcr_insert(ct, floor, fspace, key);
  1825. floor += fspace;
  1826. }
  1827. else if(high > low)
  1828. {
  1829. winchip_mcr_insert(ct, top, high, key);
  1830. top += high;
  1831. }
  1832. else if(low > 0)
  1833. {
  1834. base -= low;
  1835. winchip_mcr_insert(ct, base, low, key);
  1836. }
  1837. else break;
  1838. ct++;
  1839. }
  1840. /*
  1841.  * We loaded ct values. We now need to set the mask. The caller
  1842.  * must do this bit.
  1843.  */
  1844.  
  1845. return ct;
  1846. }
  1848. static void __init winchip_create_optimal_mcr(void)
  1849. {
  1850. int i;
  1851. /*
  1852.  * Allocate up to 6 mcrs to mark as much of ram as possible
  1853.  * as write combining and weak write ordered.
  1854.  *
  1855.  * To experiment with: Linux never uses stack operations for 
  1856.  * mmio spaces so we could globally enable stack operation wc
  1857.  *
  1858.  * Load the registers with type 31 - full write combining, all
  1859.  * writes weakly ordered.
  1860.  */
  1861. int used = winchip_mcr_compute(6, 31);
  1863. /*
  1864.  * Wipe unused MCRs
  1865.  */
  1866.  
  1867. for(i=used;i<8;i++)
  1868. wrmsr(MSR_IDT_MCR0+i, 0, 0);
  1869. }
  1871. static void __init winchip2_create_optimal_mcr(void)
  1872. {
  1873. u32 lo, hi;
  1874. int i;
  1876. /*
  1877.  * Allocate up to 6 mcrs to mark as much of ram as possible
  1878.  * as write combining, weak store ordered.
  1879.  *
  1880.  * Load the registers with type 25
  1881.  * 8 - weak write ordering
  1882.  * 16 - weak read ordering
  1883.  * 1 - write combining
  1884.  */
  1886. int used = winchip_mcr_compute(6, 25);
  1888. /*
  1889.  * Mark the registers we are using.
  1890.  */
  1891.  
  1892. rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1893. for(i=0;i<used;i++)
  1894. lo|=1<<(9+i);
  1895. wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1897. /*
  1898.  * Wipe unused MCRs
  1899.  */
  1900.  
  1901. for(i=used;i<8;i++)
  1902. wrmsr(MSR_IDT_MCR0+i, 0, 0);
  1903. }
  1905. /*
  1906.  * Handle the MCR key on the Winchip 2.
  1907.  */
  1909. static void __init winchip2_unprotect_mcr(void)
  1910. {
  1911. u32 lo, hi;
  1912. u32 key;
  1914. rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1915. lo&=~0x1C0; /* blank bits 8-6 */
  1916. key = (lo>>17) & 7;
  1917. lo |= key<<6; /* replace with unlock key */
  1918. wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1919. }
  1921. static void __init winchip2_protect_mcr(void)
  1922. {
  1923. u32 lo, hi;
  1925. rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1926. lo&=~0x1C0; /* blank bits 8-6 */
  1927. wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  1928. }
  1930. #endif
  1932. static void __init init_centaur(struct cpuinfo_x86 *c)
  1933. {
  1934. enum {
  1935. ECX8=1<<1,
  1936. EIERRINT=1<<2,
  1937. DPM=1<<3,
  1938. DMCE=1<<4,
  1939. DSTPCLK=1<<5,
  1940. ELINEAR=1<<6,
  1941. DSMC=1<<7,
  1942. DTLOCK=1<<8,
  1943. EDCTLB=1<<8,
  1944. EMMX=1<<9,
  1945. DPDC=1<<11,
  1946. EBRPRED=1<<12,
  1947. DIC=1<<13,
  1948. DDC=1<<14,
  1949. DNA=1<<15,
  1950. ERETSTK=1<<16,
  1951. E2MMX=1<<19,
  1952. EAMD3D=1<<20,
  1953. };
  1955. char *name;
  1956. u32  fcr_set=0;
  1957. u32  fcr_clr=0;
  1958. u32  lo,hi,newlo;
  1959. u32  aa,bb,cc,dd;
  1961. /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
  1962.    3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
  1963. clear_bit(0*32+31, &c->x86_capability);
  1965. switch (c->x86) {
  1967. case 5:
  1968. switch(c->x86_model) {
  1969. case 4:
  1970. name="C6";
  1971. fcr_set=ECX8|DSMC|EDCTLB|EMMX|ERETSTK;
  1972. fcr_clr=DPDC;
  1973. printk(KERN_NOTICE "Disabling bugged TSC.n");
  1974. clear_bit(X86_FEATURE_TSC, &c->x86_capability);
  1975. #ifdef CONFIG_X86_OOSTORE
  1976. winchip_create_optimal_mcr();
  1977. /* Enable
  1978. write combining on non-stack, non-string
  1979. write combining on string, all types
  1980. weak write ordering 
  1982.    The C6 original lacks weak read order 
  1983.    
  1984.    Note 0x120 is write only on Winchip 1 */
  1985.    
  1986. wrmsr(MSR_IDT_MCR_CTRL, 0x01F0001F, 0);
  1987. #endif
  1988. break;
  1989. case 8:
  1990. switch(c->x86_mask) {
  1991. default:
  1992. name="2";
  1993. break;
  1994. case 7 ... 9:
  1995. name="2A";
  1996. break;
  1997. case 10 ... 15:
  1998. name="2B";
  1999. break;
  2000. }
  2001. fcr_set=ECX8|DSMC|DTLOCK|EMMX|EBRPRED|ERETSTK|E2MMX|EAMD3D;
  2002. fcr_clr=DPDC;
  2003. #ifdef CONFIG_X86_OOSTORE
  2004. winchip2_unprotect_mcr();
  2005. winchip2_create_optimal_mcr();
  2006. rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2007. /* Enable
  2008. write combining on non-stack, non-string
  2009. write combining on string, all types
  2010. weak write ordering 
  2011. */
  2012. lo|=31;
  2013. wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2014. winchip2_protect_mcr();
  2015. #endif
  2016. break;
  2017. case 9:
  2018. name="3";
  2019. fcr_set=ECX8|DSMC|DTLOCK|EMMX|EBRPRED|ERETSTK|E2MMX|EAMD3D;
  2020. fcr_clr=DPDC;
  2021. #ifdef CONFIG_X86_OOSTORE
  2022. winchip2_unprotect_mcr();
  2023. winchip2_create_optimal_mcr();
  2024. rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2025. /* Enable
  2026. write combining on non-stack, non-string
  2027. write combining on string, all types
  2028. weak write ordering 
  2029. */
  2030. lo|=31;
  2031. wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2032. winchip2_protect_mcr();
  2033. #endif
  2034. break;
  2035. case 10:
  2036. name="4";
  2037. /* no info on the WC4 yet */
  2038. break;
  2039. default:
  2040. name="??";
  2041. }
  2043. rdmsr(MSR_IDT_FCR1, lo, hi);
  2044. newlo=(lo|fcr_set) & (~fcr_clr);
  2046. if (newlo!=lo) {
  2047. printk(KERN_INFO "Centaur FCR was 0x%X now 0x%Xn", lo, newlo );
  2048. wrmsr(MSR_IDT_FCR1, newlo, hi );
  2049. } else {
  2050. printk(KERN_INFO "Centaur FCR is 0x%Xn",lo);
  2051. }
  2052. /* Emulate MTRRs using Centaur's MCR. */
  2053. set_bit(X86_FEATURE_CENTAUR_MCR, &c->x86_capability);
  2054. /* Report CX8 */
  2055. set_bit(X86_FEATURE_CX8, &c->x86_capability);
  2056. /* Set 3DNow! on Winchip 2 and above. */
  2057. if (c->x86_model >=8)
  2058. set_bit(X86_FEATURE_3DNOW, &c->x86_capability);
  2059. /* See if we can find out some more. */
  2060. if ( cpuid_eax(0x80000000) >= 0x80000005 ) {
  2061. /* Yes, we can. */
  2062. cpuid(0x80000005,&aa,&bb,&cc,&dd);
  2063. /* Add L1 data and code cache sizes. */
  2064. c->x86_cache_size = (cc>>24)+(dd>>24);
  2065. }
  2066. sprintf( c->x86_model_id, "WinChip %s", name );
  2067. break;
  2069. case 6:
  2070. switch (c->x86_model) {
  2071. case 6 ... 8: /* Cyrix III family */
  2072. rdmsr (MSR_VIA_FCR, lo, hi);
  2073. lo |= (1<<1 | 1<<7); /* Report CX8 & enable PGE */
  2074. wrmsr (MSR_VIA_FCR, lo, hi);
  2076. set_bit(X86_FEATURE_CX8, &c->x86_capability);
  2077. set_bit(X86_FEATURE_3DNOW, &c->x86_capability);
  2079. get_model_name(c);
  2080. display_cacheinfo(c);
  2081. break;
  2082. }
  2083. break;
  2084. }
  2085. }
  2088. static void __init init_transmeta(struct cpuinfo_x86 *c)
  2089. {
  2090. unsigned int cap_mask, uk, max, dummy;
  2091. unsigned int cms_rev1, cms_rev2;
  2092. unsigned int cpu_rev, cpu_freq, cpu_flags;
  2093. char cpu_info[65];
  2095. get_model_name(c); /* Same as AMD/Cyrix */
  2096. display_cacheinfo(c);
  2098. /* Print CMS and CPU revision */
  2099. max = cpuid_eax(0x80860000);
  2100. if ( max >= 0x80860001 ) {
  2101. cpuid(0x80860001, &dummy, &cpu_rev, &cpu_freq, &cpu_flags); 
  2102. printk(KERN_INFO "CPU: Processor revision %u.%u.%u.%u, %u MHzn",
  2103.        (cpu_rev >> 24) & 0xff,
  2104.        (cpu_rev >> 16) & 0xff,
  2105.        (cpu_rev >> 8) & 0xff,
  2106.        cpu_rev & 0xff,
  2107.        cpu_freq);
  2108. }
  2109. if ( max >= 0x80860002 ) {
  2110. cpuid(0x80860002, &dummy, &cms_rev1, &cms_rev2, &dummy);
  2111. printk(KERN_INFO "CPU: Code Morphing Software revision %u.%u.%u-%u-%un",
  2112.        (cms_rev1 >> 24) & 0xff,
  2113.        (cms_rev1 >> 16) & 0xff,
  2114.        (cms_rev1 >> 8) & 0xff,
  2115.        cms_rev1 & 0xff,
  2116.        cms_rev2);
  2117. }
  2118. if ( max >= 0x80860006 ) {
  2119. cpuid(0x80860003,
  2120.       (void *)&cpu_info[0],
  2121.       (void *)&cpu_info[4],
  2122.       (void *)&cpu_info[8],
  2123.       (void *)&cpu_info[12]);
  2124. cpuid(0x80860004,
  2125.       (void *)&cpu_info[16],
  2126.       (void *)&cpu_info[20],
  2127.       (void *)&cpu_info[24],
  2128.       (void *)&cpu_info[28]);
  2129. cpuid(0x80860005,
  2130.       (void *)&cpu_info[32],
  2131.       (void *)&cpu_info[36],
  2132.       (void *)&cpu_info[40],
  2133.       (void *)&cpu_info[44]);
  2134. cpuid(0x80860006,
  2135.       (void *)&cpu_info[48],
  2136.       (void *)&cpu_info[52],
  2137.       (void *)&cpu_info[56],
  2138.       (void *)&cpu_info[60]);
  2139. cpu_info[64] = '';
  2140. printk(KERN_INFO "CPU: %sn", cpu_info);
  2141. }
  2143. /* Unhide possibly hidden capability flags */
  2144. rdmsr(0x80860004, cap_mask, uk);
  2145. wrmsr(0x80860004, ~0, uk);
  2146. c->x86_capability[0] = cpuid_edx(0x00000001);
  2147. wrmsr(0x80860004, cap_mask, uk);
  2149. /* If we can run i686 user-space code, call us an i686 */
  2150. #define USER686 (X86_FEATURE_TSC|X86_FEATURE_CX8|X86_FEATURE_CMOV)
  2151. if ( c->x86 == 5 && (c->x86_capability[0] & USER686) == USER686 )
  2152.      c->x86 = 6;
  2153. }
  2156. static void __init init_rise(struct cpuinfo_x86 *c)
  2157. {
  2158. printk("CPU: Rise iDragon");
  2159. if (c->x86_model > 2)
  2160. printk(" II");
  2161. printk("n");
  2163. /* Unhide possibly hidden capability flags
  2164.    The mp6 iDragon family don't have MSRs.
  2165.    We switch on extra features with this cpuid weirdness: */
  2166. __asm__ (
  2167. "movl $0x6363452a, %%eaxnt"
  2168. "movl $0x3231206c, %%ecxnt"
  2169. "movl $0x2a32313a, %%edxnt"
  2170. "cpuidnt"
  2171. "movl $0x63634523, %%eaxnt"
  2172. "movl $0x32315f6c, %%ecxnt"
  2173. "movl $0x2333313a, %%edxnt"
  2174. "cpuidnt" : : : "eax", "ebx", "ecx", "edx"
  2175. );
  2176. set_bit(X86_FEATURE_CX8, &c->x86_capability);
  2177. }
  2180. extern void trap_init_f00f_bug(void);
  2182. #define LVL_1_INST      1
  2183. #define LVL_1_DATA      2
  2184. #define LVL_2           3
  2185. #define LVL_3           4
  2187. struct _cache_table
  2188. {
  2189.         unsigned char descriptor;
  2190.         char cache_type;
  2191.         short size;
  2192. };
  2194. /* all the cache descriptor types we care about (no TLB or trace cache entries) */
  2195. static struct _cache_table cache_table[] __initdata =
  2196. {
  2197. { 0x06, LVL_1_INST, 8 },
  2198. { 0x08, LVL_1_INST, 16 },
  2199. { 0x0A, LVL_1_DATA, 8 },
  2200. { 0x0C, LVL_1_DATA, 16 },
  2201. { 0x22, LVL_3,      512 },
  2202. { 0x23, LVL_3,      1024 },
  2203. { 0x25, LVL_3,      2048 },
  2204. { 0x29, LVL_3,      4096 },
  2205. { 0x41, LVL_2,      128 },
  2206. { 0x42, LVL_2,      256 },
  2207. { 0x43, LVL_2,      512 },
  2208. { 0x44, LVL_2,      1024 },
  2209. { 0x45, LVL_2,      2048 },
  2210. { 0x66, LVL_1_DATA, 8 },
  2211. { 0x67, LVL_1_DATA, 16 },
  2212. { 0x68, LVL_1_DATA, 32 },
  2213. { 0x79, LVL_2,      128 },
  2214. { 0x7A, LVL_2,      256 },
  2215. { 0x7B, LVL_2,      512 },
  2216. { 0x7C, LVL_2,      1024 },
  2217. { 0x82, LVL_2,      256 },
  2218. { 0x84, LVL_2,      1024 },
  2219. { 0x85, LVL_2,      2048 },
  2220. { 0x00, 0, 0}
  2221. };
  2223. static void __init init_intel(struct cpuinfo_x86 *c)
  2224. {
  2225. unsigned int l1i = 0, l1d = 0, l2 = 0, l3 = 0; /* Cache sizes */
  2226. char *p = NULL;
  2227. #ifndef CONFIG_X86_F00F_WORKS_OK
  2228. static int f00f_workaround_enabled = 0;
  2230. /*
  2231.  * All current models of Pentium and Pentium with MMX technology CPUs
  2232.  * have the F0 0F bug, which lets nonpriviledged users lock up the system.
  2233.  * Note that the workaround only should be initialized once...
  2234.  */
  2235. c->f00f_bug = 0;
  2236. if (c->x86 == 5) {
  2237. c->f00f_bug = 1;
  2238. if (!f00f_workaround_enabled) {
  2239. trap_init_f00f_bug();
  2240. printk(KERN_NOTICE "Intel Pentium with F0 0F bug - workaround enabled.n");
  2241. f00f_workaround_enabled = 1;
  2242. }
  2243. }
  2244. #endif /* CONFIG_X86_F00F_WORKS_OK */
  2246. if (c->cpuid_level > 1) {
  2247. /* supports eax=2  call */
  2248. int i, j, n;
  2249. int regs[4];
  2250. unsigned char *dp = (unsigned char *)regs;
  2252. /* Number of times to iterate */
  2253. n = cpuid_eax(2) & 0xFF;
  2255. for ( i = 0 ; i < n ; i++ ) {
  2256. cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
  2258. /* If bit 31 is set, this is an unknown format */
  2259. for ( j = 0 ; j < 3 ; j++ ) {
  2260. if ( regs[j] < 0 ) regs[j] = 0;
  2261. }
  2263. /* Byte 0 is level count, not a descriptor */
  2264. for ( j = 1 ; j < 16 ; j++ ) {
  2265. unsigned char des = dp[j];
  2266. unsigned char k = 0;
  2268. /* look up this descriptor in the table */
  2269. while (cache_table[k].descriptor != 0)
  2270. {
  2271. if (cache_table[k].descriptor == des) {
  2272. switch (cache_table[k].cache_type) {
  2273. case LVL_1_INST:
  2274. l1i += cache_table[k].size;
  2275. break;
  2276. case LVL_1_DATA:
  2277. l1d += cache_table[k].size;
  2278. break;
  2279. case LVL_2:
  2280. l2 += cache_table[k].size;
  2281. break;
  2282. case LVL_3:
  2283. l3 += cache_table[k].size;
  2284. break;
  2285. }
  2287. break;
  2288. }
  2290. k++;
  2291. }
  2292. }
  2293. }
  2294. if ( l1i || l1d )
  2295. printk(KERN_INFO "CPU: L1 I cache: %dK, L1 D cache: %dKn",
  2296.        l1i, l1d);
  2297. if ( l2 )
  2298. printk(KERN_INFO "CPU: L2 cache: %dKn", l2);
  2299. if ( l3 )
  2300. printk(KERN_INFO "CPU: L3 cache: %dKn", l3);
  2302. /*
  2303.  * This assumes the L3 cache is shared; it typically lives in
  2304.  * the northbridge.  The L1 caches are included by the L2
  2305.  * cache, and so should not be included for the purpose of
  2306.  * SMP switching weights.
  2307.  */
  2308. c->x86_cache_size = l2 ? l2 : (l1i+l1d);
  2309. }
  2311. /* SEP CPUID bug: Pentium Pro reports SEP but doesn't have it */
  2312. if ( c->x86 == 6 && c->x86_model < 3 && c->x86_mask < 3 )
  2313. clear_bit(X86_FEATURE_SEP, &c->x86_capability);
  2315. /* Names for the Pentium II/Celeron processors 
  2316.    detectable only by also checking the cache size.
  2317.    Dixon is NOT a Celeron. */
  2318. if (c->x86 == 6) {
  2319. switch (c->x86_model) {
  2320. case 5:
  2321. if (l2 == 0)
  2322. p = "Celeron (Covington)";
  2323. if (l2 == 256)
  2324. p = "Mobile Pentium II (Dixon)";
  2325. break;
  2327. case 6:
  2328. if (l2 == 128)
  2329. p = "Celeron (Mendocino)";
  2330. break;
  2332. case 8:
  2333. if (l2 == 128)
  2334. p = "Celeron (Coppermine)";
  2335. break;
  2336. }
  2337. }
  2339. if ( p )
  2340. strcpy(c->x86_model_id, p);
  2342. #ifdef CONFIG_SMP
  2343. if (test_bit(X86_FEATURE_HT, &c->x86_capability) && !disable_x86_ht) {
  2344. extern int phys_proc_id[NR_CPUS];
  2346. u32  eax, ebx, ecx, edx;
  2347. int  index_lsb, index_msb, tmp;
  2348. int initial_apic_id;
  2349. int  cpu = smp_processor_id();
  2351. cpuid(1, &eax, &ebx, &ecx, &edx);
  2352. smp_num_siblings = (ebx & 0xff0000) >> 16;
  2354. if (smp_num_siblings == 1) {
  2355. printk(KERN_INFO  "CPU: Hyper-Threading is disabledn");
  2356. } else if (smp_num_siblings > 1 ) {
  2357. index_lsb = 0;
  2358. index_msb = 31;
  2359. /*
  2360.  * At this point we only support two siblings per
  2361.  * processor package.
  2362.  */
  2363. #define NR_SIBLINGS 2
  2364. if (smp_num_siblings != NR_SIBLINGS) {
  2365. printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
  2366. smp_num_siblings = 1;
  2367. return;
  2368. }
  2369. tmp = smp_num_siblings;
  2370. while ((tmp & 1) == 0) {
  2371. tmp >>=1 ;
  2372. index_lsb++;
  2373. }
  2374. tmp = smp_num_siblings;
  2375. while ((tmp & 0x80000000 ) == 0) {
  2376. tmp <<=1 ;
  2377. index_msb--;
  2378. }
  2379. if (index_lsb != index_msb )
  2380. index_msb++;
  2381. initial_apic_id = ebx >> 24 & 0xff;
  2382. phys_proc_id[cpu] = initial_apic_id >> index_msb;
  2384. printk(KERN_INFO  "CPU: Physical Processor ID: %dn",
  2385.                                phys_proc_id[cpu]);
  2386. }
  2388. }
  2389. #endif
  2390. }
  2392. void __init get_cpu_vendor(struct cpuinfo_x86 *c)
  2393. {
  2394. char *v = c->x86_vendor_id;
  2396. if (!strcmp(v, "GenuineIntel"))
  2397. c->x86_vendor = X86_VENDOR_INTEL;
  2398. else if (!strcmp(v, "AuthenticAMD"))
  2399. c->x86_vendor = X86_VENDOR_AMD;
  2400. else if (!strcmp(v, "CyrixInstead"))
  2401. c->x86_vendor = X86_VENDOR_CYRIX;
  2402. else if (!strcmp(v, "Geode by NSC"))
  2403. c->x86_vendor = X86_VENDOR_NSC;
  2404. else if (!strcmp(v, "UMC UMC UMC "))
  2405. c->x86_vendor = X86_VENDOR_UMC;
  2406. else if (!strcmp(v, "CentaurHauls"))
  2407. c->x86_vendor = X86_VENDOR_CENTAUR;
  2408. else if (!strcmp(v, "NexGenDriven"))
  2409. c->x86_vendor = X86_VENDOR_NEXGEN;
  2410. else if (!strcmp(v, "RiseRiseRise"))
  2411. c->x86_vendor = X86_VENDOR_RISE;
  2412. else if (!strcmp(v, "GenuineTMx86") ||
  2413.  !strcmp(v, "TransmetaCPU"))
  2414. c->x86_vendor = X86_VENDOR_TRANSMETA;
  2415. else
  2416. c->x86_vendor = X86_VENDOR_UNKNOWN;
  2417. }
  2419. struct cpu_model_info {
  2420. int vendor;
  2421. int family;
  2422. char *model_names[16];
  2423. };
  2425. /* Naming convention should be: <Name> [(<Codename>)] */
  2426. /* This table only is used unless init_<vendor>() below doesn't set it; */
  2427. /* in particular, if CPUID levels 0x80000002..4 are supported, this isn't used */
  2428. static struct cpu_model_info cpu_models[] __initdata = {
  2429. { X86_VENDOR_INTEL, 4,
  2430.   { "486 DX-25/33", "486 DX-50", "486 SX", "486 DX/2", "486 SL", 
  2431.     "486 SX/2", NULL, "486 DX/2-WB", "486 DX/4", "486 DX/4-WB", NULL, 
  2432.     NULL, NULL, NULL, NULL, NULL }},
  2433. { X86_VENDOR_INTEL, 5,
  2434.   { "Pentium 60/66 A-step", "Pentium 60/66", "Pentium 75 - 200",
  2435.     "OverDrive PODP5V83", "Pentium MMX", NULL, NULL,
  2436.     "Mobile Pentium 75 - 200", "Mobile Pentium MMX", NULL, NULL, NULL,
  2437.     NULL, NULL, NULL, NULL }},
  2438. { X86_VENDOR_INTEL, 6,
  2439.   { "Pentium Pro A-step", "Pentium Pro", NULL, "Pentium II (Klamath)", 
  2440.     NULL, "Pentium II (Deschutes)", "Mobile Pentium II",
  2441.     "Pentium III (Katmai)", "Pentium III (Coppermine)", NULL,
  2442.     "Pentium III (Cascades)", NULL, NULL, NULL, NULL }},
  2443. { X86_VENDOR_AMD, 4,
  2444.   { NULL, NULL, NULL, "486 DX/2", NULL, NULL, NULL, "486 DX/2-WB",
  2445.     "486 DX/4", "486 DX/4-WB", NULL, NULL, NULL, NULL, "Am5x86-WT",
  2446.     "Am5x86-WB" }},
  2447. { X86_VENDOR_AMD, 5, /* Is this this really necessary?? */
  2448.   { "K5/SSA5", "K5",
  2449.     "K5", "K5", NULL, NULL,
  2450.     "K6", "K6", "K6-2",
  2451.     "K6-3", NULL, NULL, NULL, NULL, NULL, NULL }},
  2452. { X86_VENDOR_AMD, 6, /* Is this this really necessary?? */
  2453.   { "Athlon", "Athlon",
  2454.     "Athlon", NULL, "Athlon", NULL,
  2455.     NULL, NULL, NULL,
  2456.     NULL, NULL, NULL, NULL, NULL, NULL, NULL }},
  2457. { X86_VENDOR_UMC, 4,
  2458.   { NULL, "U5D", "U5S", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2459.     NULL, NULL, NULL, NULL, NULL, NULL }},
  2460. { X86_VENDOR_NEXGEN, 5,
  2461.   { "Nx586", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2462.     NULL, NULL, NULL, NULL, NULL, NULL, NULL }},
  2463. { X86_VENDOR_RISE, 5,
  2464.   { "iDragon", NULL, "iDragon", NULL, NULL, NULL, NULL,
  2465.     NULL, "iDragon II", "iDragon II", NULL, NULL, NULL, NULL, NULL, NULL }},
  2466. };
  2468. /* Look up CPU names by table lookup. */
  2469. static char __init *table_lookup_model(struct cpuinfo_x86 *c)
  2470. {
  2471. struct cpu_model_info *info = cpu_models;
  2472. int i;
  2474. if ( c->x86_model >= 16 )
  2475. return NULL; /* Range check */
  2477. for ( i = 0 ; i < sizeof(cpu_models)/sizeof(struct cpu_model_info) ; i++ ) {
  2478. if ( info->vendor == c->x86_vendor &&
  2479.      info->family == c->x86 ) {
  2480. return info->model_names[c->x86_model];
  2481. }
  2482. info++;
  2483. }
  2484. return NULL; /* Not found */
  2485. }
  2487. /*
  2488.  * Detect a NexGen CPU running without BIOS hypercode new enough
  2489.  * to have CPUID. (Thanks to Herbert Oppmann)
  2490.  */
  2491.  
  2492. static int __init deep_magic_nexgen_probe(void)
  2493. {
  2494. int ret;
  2496. __asm__ __volatile__ (
  2497. " movw $0x5555, %%axn"
  2498. " xorw %%dx,%%dxn"
  2499. " movw $2, %%cxn"
  2500. " divw %%cxn"
  2501. " movl $0, %%eaxn"
  2502. " jnz 1fn"
  2503. " movl $1, %%eaxn"
  2504. "1:n" 
  2505. : "=a" (ret) : : "cx", "dx" );
  2506. return  ret;
  2507. }
  2509. static void __init squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
  2510. {
  2511. if( test_bit(X86_FEATURE_PN, &c->x86_capability) &&
  2512.     disable_x86_serial_nr ) {
  2513. /* Disable processor serial number */
  2514. unsigned long lo,hi;
  2515. rdmsr(MSR_IA32_BBL_CR_CTL,lo,hi);
  2516. lo |= 0x200000;
  2517. wrmsr(MSR_IA32_BBL_CR_CTL,lo,hi);
  2518. printk(KERN_NOTICE "CPU serial number disabled.n");
  2519. clear_bit(X86_FEATURE_PN, &c->x86_capability);
  2521. /* Disabling the serial number may affect the cpuid level */
  2522. c->cpuid_level = cpuid_eax(0);
  2523. }
  2524. }
  2527. static int __init x86_serial_nr_setup(char *s)
  2528. {
  2529. disable_x86_serial_nr = 0;
  2530. return 1;
  2531. }
  2532. __setup("serialnumber", x86_serial_nr_setup);
  2534. static int __init x86_fxsr_setup(char * s)
  2535. {
  2536. set_bit(X86_FEATURE_XMM, disabled_x86_caps); 
  2537. set_bit(X86_FEATURE_FXSR, disabled_x86_caps);
  2538. return 1;
  2539. }
  2540. __setup("nofxsr", x86_fxsr_setup);
  2543. /* Standard macro to see if a specific flag is changeable */
  2544. static inline int flag_is_changeable_p(u32 flag)
  2545. {
  2546. u32 f1, f2;
  2548. asm("pushflnt"
  2549.     "pushflnt"
  2550.     "popl %0nt"
  2551.     "movl %0,%1nt"
  2552.     "xorl %2,%0nt"
  2553.     "pushl %0nt"
  2554.     "popflnt"
  2555.     "pushflnt"
  2556.     "popl %0nt"
  2557.     "popflnt"
  2558.     : "=&r" (f1), "=&r" (f2)
  2559.     : "ir" (flag));
  2561. return ((f1^f2) & flag) != 0;
  2562. }
  2565. /* Probe for the CPUID instruction */
  2566. static int __init have_cpuid_p(void)
  2567. {
  2568. return flag_is_changeable_p(X86_EFLAGS_ID);
  2569. }
  2571. /*
  2572.  * Cyrix CPUs without cpuid or with cpuid not yet enabled can be detected
  2573.  * by the fact that they preserve the flags across the division of 5/2.
  2574.  * PII and PPro exhibit this behavior too, but they have cpuid available.
  2575.  */
  2576.  
  2577. /*
  2578.  * Perform the Cyrix 5/2 test. A Cyrix won't change
  2579.  * the flags, while other 486 chips will.
  2580.  */
  2581. static inline int test_cyrix_52div(void)
  2582. {
  2583. unsigned int test;
  2585. __asm__ __volatile__(
  2586.      "sahfnt" /* clear flags (%eax = 0x0005) */
  2587.      "div %b2nt" /* divide 5 by 2 */
  2588.      "lahf" /* store flags into %ah */
  2589.      : "=a" (test)
  2590.      : "0" (5), "q" (2)
  2591.      : "cc");
  2593. /* AH is 0x02 on Cyrix after the divide.. */
  2594. return (unsigned char) (test >> 8) == 0x02;
  2595. }
  2597. /* Try to detect a CPU with disabled CPUID, and if so, enable.  This routine
  2598.    may also be used to detect non-CPUID processors and fill in some of
  2599.    the information manually. */
  2600. static int __init id_and_try_enable_cpuid(struct cpuinfo_x86 *c)
  2601. {
  2602. /* First of all, decide if this is a 486 or higher */
  2603. /* It's a 486 if we can modify the AC flag */
  2604. if ( flag_is_changeable_p(X86_EFLAGS_AC) )
  2605. c->x86 = 4;
  2606. else
  2607. c->x86 = 3;
  2609. /* Detect Cyrix with disabled CPUID */
  2610. if ( c->x86 == 4 && test_cyrix_52div() ) {
  2611. unsigned char dir0, dir1;
  2613. strcpy(c->x86_vendor_id, "CyrixInstead");
  2614.         c->x86_vendor = X86_VENDOR_CYRIX;
  2615.         
  2616.         /* Actually enable cpuid on the older cyrix */
  2617.     
  2618.      /* Retrieve CPU revisions */
  2619.     
  2620. do_cyrix_devid(&dir0, &dir1);
  2622. dir0>>=4;
  2624. /* Check it is an affected model */
  2626.             if (dir0 == 5 || dir0 == 3)
  2627.             {
  2628. unsigned char ccr3, ccr4;
  2629. unsigned long flags;
  2630. printk(KERN_INFO "Enabling CPUID on Cyrix processor.n");
  2631. local_irq_save(flags);
  2632. ccr3 = getCx86(CX86_CCR3);
  2633. setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
  2634. ccr4 = getCx86(CX86_CCR4);
  2635. setCx86(CX86_CCR4, ccr4 | 0x80);          /* enable cpuid  */
  2636. setCx86(CX86_CCR3, ccr3);                 /* disable MAPEN */
  2637. local_irq_restore(flags);
  2638. }
  2639. } else
  2641. /* Detect NexGen with old hypercode */
  2642. if ( deep_magic_nexgen_probe() ) {
  2643. strcpy(c->x86_vendor_id, "NexGenDriven");
  2644. }
  2646. return have_cpuid_p(); /* Check to see if CPUID now enabled? */
  2647. }
  2649. /*
  2650.  * This does the hard work of actually picking apart the CPU stuff...
  2651.  */
  2652. void __init identify_cpu(struct cpuinfo_x86 *c)
  2653. {
  2654. int junk, i;
  2655. u32 xlvl, tfms;
  2657. c->loops_per_jiffy = loops_per_jiffy;
  2658. c->x86_cache_size = -1;
  2659. c->x86_vendor = X86_VENDOR_UNKNOWN;
  2660. c->cpuid_level = -1; /* CPUID not detected */
  2661. c->x86_model = c->x86_mask = 0; /* So far unknown... */
  2662. c->x86_vendor_id[0] = ''; /* Unset */
  2663. c->x86_model_id[0] = '';  /* Unset */
  2664. memset(&c->x86_capability, 0, sizeof c->x86_capability);
  2666. if ( !have_cpuid_p() && !id_and_try_enable_cpuid(c) ) {
  2667. /* CPU doesn't have CPUID */
  2669. /* If there are any capabilities, they're vendor-specific */
  2670. /* enable_cpuid() would have set c->x86 for us. */
  2671. } else {
  2672. /* CPU does have CPUID */
  2674. /* Get vendor name */
  2675. cpuid(0x00000000, &c->cpuid_level,
  2676.       (int *)&c->x86_vendor_id[0],
  2677.       (int *)&c->x86_vendor_id[8],
  2678.       (int *)&c->x86_vendor_id[4]);
  2680. get_cpu_vendor(c);
  2681. /* Initialize the standard set of capabilities */
  2682. /* Note that the vendor-specific code below might override */
  2684. /* Intel-defined flags: level 0x00000001 */
  2685. if ( c->cpuid_level >= 0x00000001 ) {
  2686. cpuid(0x00000001, &tfms, &junk, &junk,
  2687.       &c->x86_capability[0]);
  2688. c->x86 = (tfms >> 8) & 15;
  2689. c->x86_model = (tfms >> 4) & 15;
  2690. c->x86_mask = tfms & 15;
  2691. } else {
  2692. /* Have CPUID level 0 only - unheard of */
  2693. c->x86 = 4;
  2694. }
  2696. /* AMD-defined flags: level 0x80000001 */
  2697. xlvl = cpuid_eax(0x80000000);
  2698. if ( (xlvl & 0xffff0000) == 0x80000000 ) {
  2699. if ( xlvl >= 0x80000001 )
  2700. c->x86_capability[1] = cpuid_edx(0x80000001);
  2701. if ( xlvl >= 0x80000004 )
  2702. get_model_name(c); /* Default name */
  2703. }
  2705. /* Transmeta-defined flags: level 0x80860001 */
  2706. xlvl = cpuid_eax(0x80860000);
  2707. if ( (xlvl & 0xffff0000) == 0x80860000 ) {
  2708. if (  xlvl >= 0x80860001 )
  2709. c->x86_capability[2] = cpuid_edx(0x80860001);
  2710. }
  2711. }
  2713. /*
  2714.  * Vendor-specific initialization.  In this section we
  2715.  * canonicalize the feature flags, meaning if there are
  2716.  * features a certain CPU supports which CPUID doesn't
  2717.  * tell us, CPUID claiming incorrect flags, or other bugs,
  2718.  * we handle them here.
  2719.  *
  2720.  * At the end of this section, c->x86_capability better
  2721.  * indicate the features this CPU genuinely supports!
  2722.  */
  2723. switch ( c->x86_vendor ) {
  2724. case X86_VENDOR_UNKNOWN:
  2725. default:
  2726. /* Not much we can do here... */
  2727. /* Check if at least it has cpuid */
  2728. if (c->cpuid_level == -1)
  2729. {
  2730. /* No cpuid. It must be an ancient CPU */
  2731. if (c->x86 == 4)
  2732. strcpy(c->x86_model_id, "486");
  2733. else if (c->x86 == 3)
  2734. strcpy(c->x86_model_id, "386");
  2735. }
  2736. break;
  2738. case X86_VENDOR_CYRIX:
  2739. init_cyrix(c);
  2740. break;
  2742. case X86_VENDOR_NSC:
  2743.         init_cyrix(c);
  2744. break;
  2746. case X86_VENDOR_AMD:
  2747. init_amd(c);
  2748. break;
  2750. case X86_VENDOR_CENTAUR:
  2751. init_centaur(c);
  2752. break;
  2754. case X86_VENDOR_INTEL:
  2755. init_intel(c);
  2756. break;
  2758. case X86_VENDOR_NEXGEN:
  2759. c->x86_cache_size = 256; /* A few had 1 MB... */
  2760. break;
  2762. case X86_VENDOR_TRANSMETA:
  2763. init_transmeta(c);
  2764. break;
  2766. case X86_VENDOR_RISE:
  2767. init_rise(c);
  2768. break;
  2769. }
  2771. /*
  2772.  * The vendor-specific functions might have changed features.  Now
  2773.  * we do "generic changes."
  2774.  */
  2776. /* TSC disabled? */
  2777. #ifndef CONFIG_X86_TSC
  2778. if ( tsc_disable )
  2779. clear_bit(X86_FEATURE_TSC, &c->x86_capability);
  2780. #endif
  2782. /* check for caps that have been disabled earlier */ 
  2783. for (i = 0; i < NCAPINTS; i++) { 
  2784.      c->x86_capability[i] &= ~disabled_x86_caps[i];
  2785. }
  2787. /* Disable the PN if appropriate */
  2788. squash_the_stupid_serial_number(c);
  2790. /* Init Machine Check Exception if available. */
  2791. mcheck_init(c);
  2793. /* If the model name is still unset, do table lookup. */
  2794. if ( !c->x86_model_id[0] ) {
  2795. char *p;
  2796. p = table_lookup_model(c);
  2797. if ( p )
  2798. strcpy(c->x86_model_id, p);
  2799. else
  2800. /* Last resort... */
  2801. sprintf(c->x86_model_id, "%02x/%02x",
  2802. c->x86_vendor, c->x86_model);
  2803. }
  2805. /* Now the feature flags better reflect actual CPU features! */
  2807. printk(KERN_DEBUG "CPU:     After generic, caps: %08x %08x %08x %08xn",
  2808.        c->x86_capability[0],
  2809.        c->x86_capability[1],
  2810.        c->x86_capability[2],
  2811.        c->x86_capability[3]);
  2813. /*
  2814.  * On SMP, boot_cpu_data holds the common feature set between
  2815.  * all CPUs; so make sure that we indicate which features are
  2816.  * common between the CPUs.  The first time this routine gets
  2817.  * executed, c == &boot_cpu_data.
  2818.  */
  2819. if ( c != &boot_cpu_data ) {
  2820. /* AND the already accumulated flags with these */
  2821. for ( i = 0 ; i < NCAPINTS ; i++ )
  2822. boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
  2823. }
  2825. printk(KERN_DEBUG "CPU:             Common caps: %08x %08x %08x %08xn",
  2826.        boot_cpu_data.x86_capability[0],
  2827.        boot_cpu_data.x86_capability[1],
  2828.        boot_cpu_data.x86_capability[2],
  2829.        boot_cpu_data.x86_capability[3]);
  2830. }
  2831. /*
  2832.  * Perform early boot up checks for a valid TSC. See arch/i386/kernel/time.c
  2833.  */
  2834.  
  2835. void __init dodgy_tsc(void)
  2836. {
  2837. get_cpu_vendor(&boot_cpu_data);
  2839. if ( boot_cpu_data.x86_vendor == X86_VENDOR_CYRIX ||
  2840.      boot_cpu_data.x86_vendor == X86_VENDOR_NSC )
  2841. init_cyrix(&boot_cpu_data);
  2842. }
  2845. /* These need to match <asm/processor.h> */
  2846. static char *cpu_vendor_names[] __initdata = {
  2847. "Intel", "Cyrix", "AMD", "UMC", "NexGen", 
  2848. "Centaur", "Rise", "Transmeta", "NSC"
  2849. };
  2852. void __init print_cpu_info(struct cpuinfo_x86 *c)
  2853. {
  2854. char *vendor = NULL;
  2856. if (c->x86_vendor < sizeof(cpu_vendor_names)/sizeof(char *))
  2857. vendor = cpu_vendor_names[c->x86_vendor];
  2858. else if (c->cpuid_level >= 0)
  2859. vendor = c->x86_vendor_id;
  2861. if (vendor && strncmp(c->x86_model_id, vendor, strlen(vendor)))
  2862. printk("%s ", vendor);
  2864. if (!c->x86_model_id[0])
  2865. printk("%d86", c->x86);
  2866. else
  2867. printk("%s", c->x86_model_id);
  2869. if (c->x86_mask || c->cpuid_level >= 0) 
  2870. printk(" stepping %02xn", c->x86_mask);
  2871. else
  2872. printk("n");
  2873. }
  2875. /*
  2876.  * Get CPU information for use by the procfs.
  2877.  */
  2878. static int show_cpuinfo(struct seq_file *m, void *v)
  2879. {
  2880. /* 
  2881.  * These flag bits must match the definitions in <asm/cpufeature.h>.
  2882.  * NULL means this bit is undefined or reserved; either way it doesn't
  2883.  * have meaning as far as Linux is concerned.  Note that it's important
  2884.  * to realize there is a difference between this table and CPUID -- if
  2885.  * applications want to get the raw CPUID data, they should access
  2886.  * /dev/cpu/<cpu_nr>/cpuid instead.
  2887.  */
  2888. static char *x86_cap_flags[] = {
  2889. /* Intel-defined */
  2890.         "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
  2891.         "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
  2892.         "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
  2893.         "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
  2895. /* AMD-defined */
  2896. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2897. NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
  2898. NULL, NULL, NULL, NULL, NULL, NULL, "mmxext", NULL,
  2899. NULL, NULL, NULL, NULL, NULL, "lm", "3dnowext", "3dnow",
  2901. /* Transmeta-defined */
  2902. "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
  2903. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2904. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2905. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2907. /* Other (Linux-defined) */
  2908. "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr", NULL, NULL, NULL, NULL,
  2909. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2910. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2911. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  2912. };
  2913. struct cpuinfo_x86 *c = v;
  2914. int i, n = c - cpu_data;
  2915. int fpu_exception;
  2917. #ifdef CONFIG_SMP
  2918. if (!(cpu_online_map & (1<<n)))
  2919. return 0;
  2920. #endif
  2921. seq_printf(m, "processort: %dn"
  2922. "vendor_idt: %sn"
  2923. "cpu familyt: %dn"
  2924. "modeltt: %dn"
  2925. "model namet: %sn",
  2926. n,
  2927. c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
  2928. c->x86,
  2929. c->x86_model,
  2930. c->x86_model_id[0] ? c->x86_model_id : "unknown");
  2932. if (c->x86_mask || c->cpuid_level >= 0)
  2933. seq_printf(m, "steppingt: %dn", c->x86_mask);
  2934. else
  2935. seq_printf(m, "steppingt: unknownn");
  2937. if ( test_bit(X86_FEATURE_TSC, &c->x86_capability) ) {
  2938. seq_printf(m, "cpu MHztt: %lu.%03lun",
  2939. cpu_khz / 1000, (cpu_khz % 1000));
  2940. }
  2942. /* Cache size */
  2943. if (c->x86_cache_size >= 0)
  2944. seq_printf(m, "cache sizet: %d KBn", c->x86_cache_size);
  2946. /* We use exception 16 if we have hardware math and we've either seen it or the CPU claims it is internal */
  2947. fpu_exception = c->hard_math && (ignore_irq13 || cpu_has_fpu);
  2948. seq_printf(m, "fdiv_bugt: %sn"
  2949. "hlt_bugtt: %sn"
  2950. "f00f_bugt: %sn"
  2951. "coma_bugt: %sn"
  2952. "fputt: %sn"
  2953. "fpu_exceptiont: %sn"
  2954. "cpuid levelt: %dn"
  2955. "wptt: %sn"
  2956. "flagstt:",
  2957.      c->fdiv_bug ? "yes" : "no",
  2958.      c->hlt_works_ok ? "no" : "yes",
  2959.      c->f00f_bug ? "yes" : "no",
  2960.      c->coma_bug ? "yes" : "no",
  2961.      c->hard_math ? "yes" : "no",
  2962.      fpu_exception ? "yes" : "no",
  2963.      c->cpuid_level,
  2964.      c->wp_works_ok ? "yes" : "no");
  2966. for ( i = 0 ; i < 32*NCAPINTS ; i++ )
  2967. if ( test_bit(i, &c->x86_capability) &&
  2968.      x86_cap_flags[i] != NULL )
  2969. seq_printf(m, " %s", x86_cap_flags[i]);
  2971. seq_printf(m, "nbogomipst: %lu.%02lunn",
  2972.      c->loops_per_jiffy/(500000/HZ),
  2973.      (c->loops_per_jiffy/(5000/HZ)) % 100);
  2974. return 0;
  2975. }
  2977. static void *c_start(struct seq_file *m, loff_t *pos)
  2978. {
  2979. return *pos < NR_CPUS ? cpu_data + *pos : NULL;
  2980. }
  2981. static void *c_next(struct seq_file *m, void *v, loff_t *pos)
  2982. {
  2983. ++*pos;
  2984. return c_start(m, pos);
  2985. }
  2986. static void c_stop(struct seq_file *m, void *v)
  2987. {
  2988. }
  2989. struct seq_operations cpuinfo_op = {
  2990. start: c_start,
  2991. next: c_next,
  2992. stop: c_stop,
  2993. show: show_cpuinfo,
  2994. };
  2996. unsigned long cpu_initialized __initdata = 0;
  2998. /*
  2999.  * cpu_init() initializes state that is per-CPU. Some data is already
  3000.  * initialized (naturally) in the bootstrap process, such as the GDT
  3001.  * and IDT. We reload them nevertheless, this function acts as a
  3002.  * 'CPU state barrier', nothing should get across.
  3003.  */
  3004. void __init cpu_init (void)
  3005. {
  3006. int nr = smp_processor_id();
  3007. struct tss_struct * t = &init_tss[nr];
  3009. if (test_and_set_bit(nr, &cpu_initialized)) {
  3010. printk(KERN_WARNING "CPU#%d already initialized!n", nr);
  3011. for (;;) __sti();
  3012. }
  3013. printk(KERN_INFO "Initializing CPU#%dn", nr);
  3015. if (cpu_has_vme || cpu_has_tsc || cpu_has_de)
  3016. clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);
  3017. #ifndef CONFIG_X86_TSC
  3018. if (tsc_disable && cpu_has_tsc) {
  3019. printk(KERN_NOTICE "Disabling TSC...n");
  3020. /**** FIX-HPA: DOES THIS REALLY BELONG HERE? ****/
  3021. clear_bit(X86_FEATURE_TSC, boot_cpu_data.x86_capability);
  3022. set_in_cr4(X86_CR4_TSD);
  3023. }
  3024. #endif
  3026. __asm__ __volatile__("lgdt %0": "=m" (gdt_descr));
  3027. __asm__ __volatile__("lidt %0": "=m" (idt_descr));
  3029. /*
  3030.  * Delete NT
  3031.  */
  3032. __asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl");
  3034. /*
  3035.  * set up and load the per-CPU TSS and LDT
  3036.  */
  3037. atomic_inc(&init_mm.mm_count);
  3038. current->active_mm = &init_mm;
  3039. if(current->mm)
  3040. BUG();
  3041. enter_lazy_tlb(&init_mm, current, nr);
  3043. t->esp0 = current->thread.esp0;
  3044. set_tss_desc(nr,t);
  3045. gdt_table[__TSS(nr)].b &= 0xfffffdff;
  3046. load_TR(nr);
  3047. load_LDT(&init_mm);
  3049. /*
  3050.  * Clear all 6 debug registers:
  3051.  */
  3053. #define CD(register) __asm__("movl %0,%%db" #register ::"r"(0) );
  3055. CD(0); CD(1); CD(2); CD(3); /* no db4 and db5 */; CD(6); CD(7);
  3057. #undef CD
  3059. /*
  3060.  * Force FPU initialization:
  3061.  */
  3062. current->flags &= ~PF_USEDFPU;
  3063. current->used_math = 0;
  3064. stts();
  3065. }
  3067. /*
  3068.  * Early probe support logic for ppro memory erratum #50
  3069.  *
  3070.  * This is called before we do cpu ident work
  3071.  */
  3072.  
  3073. int __init ppro_with_ram_bug(void)
  3074. {
  3075. char vendor_id[16];
  3076. int ident;
  3078. /* Must have CPUID */
  3079. if(!have_cpuid_p())
  3080. return 0;
  3081. if(cpuid_eax(0)<1)
  3082. return 0;
  3084. /* Must be Intel */
  3085. cpuid(0, &ident, 
  3086. (int *)&vendor_id[0],
  3087. (int *)&vendor_id[8],
  3088. (int *)&vendor_id[4]);
  3090. if(memcmp(vendor_id, "IntelInside", 12))
  3091. return 0;
  3093. ident = cpuid_eax(1);
  3095. /* Model 6 */
  3097. if(((ident>>8)&15)!=6)
  3098. return 0;
  3100. /* Pentium Pro */
  3102. if(((ident>>4)&15)!=1)
  3103. return 0;
  3105. if((ident&15) < 8)
  3106. {
  3107. printk(KERN_INFO "Pentium Pro with Errata#50 detected. Taking evasive action.n");
  3108. return 1;
  3109. }
  3110. printk(KERN_INFO "Your Pentium Pro seems ok.n");
  3111. return 0;
  3112. }
  3114. /*
  3115.  * Local Variables:
  3116.  * mode:c
  3117.  * c-file-style:"k&r"
  3118.  * c-basic-offset:8
  3119.  * End:
  3120.  */