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

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

Linux/Unix编程

开发平台：

Unix_Linux

mtrr.c：源码内容
  1. /*  Generic MTRR (Memory Type Range Register) driver.
  3.     Copyright (C) 1997-2000  Richard Gooch
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.     Richard Gooch may be reached by email at  rgooch@atnf.csiro.au
  20.     The postal address is:
  21.       Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
  23.     Source: "Pentium Pro Family Developer's Manual, Volume 3:
  24.     Operating System Writer's Guide" (Intel document number 242692),
  25.     section 11.11.7
  27.     ChangeLog
  29.     Prehistory Martin Tischh鋟ser <martin@ikcbarka.fzk.de>
  30.        Initial register-setting code (from proform-1.0).
  31.     19971216   Richard Gooch <rgooch@atnf.csiro.au>
  32.                Original version for /proc/mtrr interface, SMP-safe.
  33.   v1.0
  34.     19971217   Richard Gooch <rgooch@atnf.csiro.au>
  35.                Bug fix for ioctls()'s.
  36.        Added sample code in Documentation/mtrr.txt
  37.   v1.1
  38.     19971218   Richard Gooch <rgooch@atnf.csiro.au>
  39.                Disallow overlapping regions.
  40.     19971219   Jens Maurer <jmaurer@menuett.rhein-main.de>
  41.                Register-setting fixups.
  42.   v1.2
  43.     19971222   Richard Gooch <rgooch@atnf.csiro.au>
  44.                Fixups for kernel 2.1.75.
  45.   v1.3
  46.     19971229   David Wragg <dpw@doc.ic.ac.uk>
  47.                Register-setting fixups and conformity with Intel conventions.
  48.     19971229   Richard Gooch <rgooch@atnf.csiro.au>
  49.                Cosmetic changes and wrote this ChangeLog ;-)
  50.     19980106   Richard Gooch <rgooch@atnf.csiro.au>
  51.                Fixups for kernel 2.1.78.
  52.   v1.4
  53.     19980119   David Wragg <dpw@doc.ic.ac.uk>
  54.                Included passive-release enable code (elsewhere in PCI setup).
  55.   v1.5
  56.     19980131   Richard Gooch <rgooch@atnf.csiro.au>
  57.                Replaced global kernel lock with private spinlock.
  58.   v1.6
  59.     19980201   Richard Gooch <rgooch@atnf.csiro.au>
  60.                Added wait for other CPUs to complete changes.
  61.   v1.7
  62.     19980202   Richard Gooch <rgooch@atnf.csiro.au>
  63.                Bug fix in definition of <set_mtrr> for UP.
  64.   v1.8
  65.     19980319   Richard Gooch <rgooch@atnf.csiro.au>
  66.                Fixups for kernel 2.1.90.
  67.     19980323   Richard Gooch <rgooch@atnf.csiro.au>
  68.                Move SMP BIOS fixup before secondary CPUs call <calibrate_delay>
  69.   v1.9
  70.     19980325   Richard Gooch <rgooch@atnf.csiro.au>
  71.                Fixed test for overlapping regions: confused by adjacent regions
  72.     19980326   Richard Gooch <rgooch@atnf.csiro.au>
  73.                Added wbinvd in <set_mtrr_prepare>.
  74.     19980401   Richard Gooch <rgooch@atnf.csiro.au>
  75.                Bug fix for non-SMP compilation.
  76.     19980418   David Wragg <dpw@doc.ic.ac.uk>
  77.                Fixed-MTRR synchronisation for SMP and use atomic operations
  78.        instead of spinlocks.
  79.     19980418   Richard Gooch <rgooch@atnf.csiro.au>
  80.        Differentiate different MTRR register classes for BIOS fixup.
  81.   v1.10
  82.     19980419   David Wragg <dpw@doc.ic.ac.uk>
  83.        Bug fix in variable MTRR synchronisation.
  84.   v1.11
  85.     19980419   Richard Gooch <rgooch@atnf.csiro.au>
  86.        Fixups for kernel 2.1.97.
  87.   v1.12
  88.     19980421   Richard Gooch <rgooch@atnf.csiro.au>
  89.        Safer synchronisation across CPUs when changing MTRRs.
  90.   v1.13
  91.     19980423   Richard Gooch <rgooch@atnf.csiro.au>
  92.        Bugfix for SMP systems without MTRR support.
  93.   v1.14
  94.     19980427   Richard Gooch <rgooch@atnf.csiro.au>
  95.        Trap calls to <mtrr_add> and <mtrr_del> on non-MTRR machines.
  96.   v1.15
  97.     19980427   Richard Gooch <rgooch@atnf.csiro.au>
  98.        Use atomic bitops for setting SMP change mask.
  99.   v1.16
  100.     19980428   Richard Gooch <rgooch@atnf.csiro.au>
  101.        Removed spurious diagnostic message.
  102.   v1.17
  103.     19980429   Richard Gooch <rgooch@atnf.csiro.au>
  104.        Moved register-setting macros into this file.
  105.        Moved setup code from init/main.c to i386-specific areas.
  106.   v1.18
  107.     19980502   Richard Gooch <rgooch@atnf.csiro.au>
  108.        Moved MTRR detection outside conditionals in <mtrr_init>.
  109.   v1.19
  110.     19980502   Richard Gooch <rgooch@atnf.csiro.au>
  111.        Documentation improvement: mention Pentium II and AGP.
  112.   v1.20
  113.     19980521   Richard Gooch <rgooch@atnf.csiro.au>
  114.        Only manipulate interrupt enable flag on local CPU.
  115.        Allow enclosed uncachable regions.
  116.   v1.21
  117.     19980611   Richard Gooch <rgooch@atnf.csiro.au>
  118.        Always define <main_lock>.
  119.   v1.22
  120.     19980901   Richard Gooch <rgooch@atnf.csiro.au>
  121.        Removed module support in order to tidy up code.
  122.        Added sanity check for <mtrr_add>/<mtrr_del> before <mtrr_init>.
  123.        Created addition queue for prior to SMP commence.
  124.   v1.23
  125.     19980902   Richard Gooch <rgooch@atnf.csiro.au>
  126.        Ported patch to kernel 2.1.120-pre3.
  127.   v1.24
  128.     19980910   Richard Gooch <rgooch@atnf.csiro.au>
  129.        Removed sanity checks and addition queue: Linus prefers an OOPS.
  130.   v1.25
  131.     19981001   Richard Gooch <rgooch@atnf.csiro.au>
  132.        Fixed harmless compiler warning in include/asm-i386/mtrr.h
  133.        Fixed version numbering and history for v1.23 -> v1.24.
  134.   v1.26
  135.     19990118   Richard Gooch <rgooch@atnf.csiro.au>
  136.        Added devfs support.
  137.   v1.27
  138.     19990123   Richard Gooch <rgooch@atnf.csiro.au>
  139.        Changed locking to spin with reschedule.
  140.        Made use of new <smp_call_function>.
  141.   v1.28
  142.     19990201   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  143.        Extended the driver to be able to use Cyrix style ARRs.
  144.     19990204   Richard Gooch <rgooch@atnf.csiro.au>
  145.        Restructured Cyrix support.
  146.   v1.29
  147.     19990204   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  148.        Refined ARR support: enable MAPEN in set_mtrr_prepare()
  149.        and disable MAPEN in set_mtrr_done().
  150.     19990205   Richard Gooch <rgooch@atnf.csiro.au>
  151.        Minor cleanups.
  152.   v1.30
  153.     19990208   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  154.                Protect plain 6x86s (and other processors without the
  155.                Page Global Enable feature) against accessing CR4 in
  156.                set_mtrr_prepare() and set_mtrr_done().
  157.     19990210   Richard Gooch <rgooch@atnf.csiro.au>
  158.        Turned <set_mtrr_up> and <get_mtrr> into function pointers.
  159.   v1.31
  160.     19990212   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  161.                Major rewrite of cyrix_arr_init(): do not touch ARRs,
  162.                leave them as the BIOS have set them up.
  163.                Enable usage of all 8 ARRs.
  164.                Avoid multiplications by 3 everywhere and other
  165.                code clean ups/speed ups.
  166.     19990213   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  167.                Set up other Cyrix processors identical to the boot cpu.
  168.                Since Cyrix don't support Intel APIC, this is l'art pour l'art.
  169.                Weigh ARRs by size:
  170.                If size <= 32M is given, set up ARR# we were given.
  171.                If size >  32M is given, set up ARR7 only if it is free,
  172.                fail otherwise.
  173.     19990214   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  174.                Also check for size >= 256K if we are to set up ARR7,
  175.                mtrr_add() returns the value it gets from set_mtrr()
  176.     19990218   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  177.                Remove Cyrix "coma bug" workaround from here.
  178.                Moved to linux/arch/i386/kernel/setup.c and
  179.                linux/include/asm-i386/bugs.h
  180.     19990228   Richard Gooch <rgooch@atnf.csiro.au>
  181.        Added MTRRIOC_KILL_ENTRY ioctl(2)
  182.        Trap for counter underflow in <mtrr_file_del>.
  183.        Trap for 4 MiB aligned regions for PPro, stepping <= 7.
  184.     19990301   Richard Gooch <rgooch@atnf.csiro.au>
  185.        Created <get_free_region> hook.
  186.     19990305   Richard Gooch <rgooch@atnf.csiro.au>
  187.        Temporarily disable AMD support now MTRR capability flag is set.
  188.   v1.32
  189.     19990308   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  190.        Adjust my changes (19990212-19990218) to Richard Gooch's
  191.        latest changes. (19990228-19990305)
  192.   v1.33
  193.     19990309   Richard Gooch <rgooch@atnf.csiro.au>
  194.        Fixed typo in <printk> message.
  195.     19990310   Richard Gooch <rgooch@atnf.csiro.au>
  196.        Support K6-II/III based on Alan Cox's <alan@redhat.com> patches.
  197.   v1.34
  198.     19990511   Bart Hartgers <bart@etpmod.phys.tue.nl>
  199.        Support Centaur C6 MCR's.
  200.     19990512   Richard Gooch <rgooch@atnf.csiro.au>
  201.        Minor cleanups.
  202.   v1.35
  203.     19990707   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  204.                Check whether ARR3 is protected in cyrix_get_free_region()
  205.                and mtrr_del(). The code won't attempt to delete or change it
  206.                from now on if the BIOS protected ARR3. It silently skips ARR3
  207.                in cyrix_get_free_region() or returns with an error code from
  208.                mtrr_del().
  209.     19990711   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  210.                Reset some bits in the CCRs in cyrix_arr_init() to disable SMM
  211.                if ARR3 isn't protected. This is needed because if SMM is active
  212.                and ARR3 isn't protected then deleting and setting ARR3 again
  213.                may lock up the processor. With SMM entirely disabled, it does
  214.                not happen.
  215.     19990812   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  216.                Rearrange switch() statements so the driver accomodates to
  217.                the fact that the AMD Athlon handles its MTRRs the same way
  218.                as Intel does.
  219.     19990814   Zolt醤 B鰏z鰎m閚yi <zboszor@mail.externet.hu>
  220.        Double check for Intel in mtrr_add()'s big switch() because
  221.        that revision check is only valid for Intel CPUs.
  222.     19990819   Alan Cox <alan@redhat.com>
  223.                Tested Zoltan's changes on a pre production Athlon - 100%
  224.                success.
  225.     19991008   Manfred Spraul <manfreds@colorfullife.com>
  226.             replaced spin_lock_reschedule() with a normal semaphore.
  227.   v1.36
  228.     20000221   Richard Gooch <rgooch@atnf.csiro.au>
  229.                Compile fix if procfs and devfs not enabled.
  230.        Formatting changes.
  231.   v1.37
  232.     20001109   H. Peter Anvin <hpa@zytor.com>
  233.        Use the new centralized CPU feature detects.
  235.   v1.38
  236.     20010309   Dave Jones <davej@suse.de>
  237.        Add support for Cyrix III.
  239.   v1.39
  240.     20010312   Dave Jones <davej@suse.de>
  241.                Ugh, I broke AMD support.
  242.        Reworked fix by Troels Walsted Hansen <troels@thule.no>
  244.   v1.40
  245.     20010327   Dave Jones <davej@suse.de>
  246.        Adapted Cyrix III support to include VIA C3.
  248. */
  249. #include <linux/types.h>
  250. #include <linux/errno.h>
  251. #include <linux/sched.h>
  252. #include <linux/tty.h>
  253. #include <linux/timer.h>
  254. #include <linux/config.h>
  255. #include <linux/kernel.h>
  256. #include <linux/wait.h>
  257. #include <linux/string.h>
  258. #include <linux/slab.h>
  259. #include <linux/ioport.h>
  260. #include <linux/delay.h>
  261. #include <linux/fs.h>
  262. #include <linux/ctype.h>
  263. #include <linux/proc_fs.h>
  264. #include <linux/devfs_fs_kernel.h>
  265. #include <linux/mm.h>
  266. #include <linux/module.h>
  267. #include <linux/pci.h>
  268. #define MTRR_NEED_STRINGS
  269. #include <asm/mtrr.h>
  270. #include <linux/init.h>
  271. #include <linux/smp.h>
  272. #include <linux/smp_lock.h>
  274. #include <asm/uaccess.h>
  275. #include <asm/io.h>
  276. #include <asm/processor.h>
  277. #include <asm/system.h>
  278. #include <asm/pgtable.h>
  279. #include <asm/segment.h>
  280. #include <asm/bitops.h>
  281. #include <asm/atomic.h>
  282. #include <asm/msr.h>
  284. #include <asm/hardirq.h>
  285. #include <linux/irq.h>
  287. #define MTRR_VERSION            "1.40 (20010327)"
  289. #define TRUE  1
  290. #define FALSE 0
  292. /*
  293.  * The code assumes all processors support the same MTRR
  294.  * interface.  This is generally a good assumption, but could
  295.  * potentially be a problem.
  296.  */
  297. enum mtrr_if_type {
  298.     MTRR_IF_NONE, /* No MTRRs supported */
  299.     MTRR_IF_INTEL, /* Intel (P6) standard MTRRs */
  300.     MTRR_IF_AMD_K6, /* AMD pre-Athlon MTRRs */
  301.     MTRR_IF_CYRIX_ARR, /* Cyrix ARRs */
  302.     MTRR_IF_CENTAUR_MCR, /* Centaur MCRs */
  303. } mtrr_if = MTRR_IF_NONE;
  305. static __initdata char *mtrr_if_name[] = {
  306.     "none", "Intel", "AMD K6", "Cyrix ARR", "Centaur MCR"
  307. };
  309. #define MTRRcap_MSR     0x0fe
  310. #define MTRRdefType_MSR 0x2ff
  312. #define MTRRphysBase_MSR(reg) (0x200 + 2 * (reg))
  313. #define MTRRphysMask_MSR(reg) (0x200 + 2 * (reg) + 1)
  315. #define NUM_FIXED_RANGES 88
  316. #define MTRRfix64K_00000_MSR 0x250
  317. #define MTRRfix16K_80000_MSR 0x258
  318. #define MTRRfix16K_A0000_MSR 0x259
  319. #define MTRRfix4K_C0000_MSR 0x268
  320. #define MTRRfix4K_C8000_MSR 0x269
  321. #define MTRRfix4K_D0000_MSR 0x26a
  322. #define MTRRfix4K_D8000_MSR 0x26b
  323. #define MTRRfix4K_E0000_MSR 0x26c
  324. #define MTRRfix4K_E8000_MSR 0x26d
  325. #define MTRRfix4K_F0000_MSR 0x26e
  326. #define MTRRfix4K_F8000_MSR 0x26f
  328. #ifdef CONFIG_SMP
  329. #  define MTRR_CHANGE_MASK_FIXED     0x01
  330. #  define MTRR_CHANGE_MASK_VARIABLE  0x02
  331. #  define MTRR_CHANGE_MASK_DEFTYPE   0x04
  332. #endif
  334. /* In the Intel processor's MTRR interface, the MTRR type is always held in
  335.    an 8 bit field: */
  336. typedef u8 mtrr_type;
  338. #define LINE_SIZE      80
  339. #define JIFFIE_TIMEOUT 100
  341. #ifdef CONFIG_SMP
  342. #  define set_mtrr(reg,base,size,type) set_mtrr_smp (reg, base, size, type)
  343. #else
  344. #  define set_mtrr(reg,base,size,type) (*set_mtrr_up) (reg, base, size, type, 
  345.        TRUE)
  346. #endif
  348. #if defined(CONFIG_PROC_FS) || defined(CONFIG_DEVFS_FS)
  349. # define USERSPACE_INTERFACE
  350. #endif
  352. #ifndef USERSPACE_INTERFACE
  353. #  define compute_ascii() while (0)
  354. #endif
  356. #ifdef USERSPACE_INTERFACE
  357. static char *ascii_buffer;
  358. static unsigned int ascii_buf_bytes;
  359. #endif
  360. static unsigned int *usage_table;
  361. static DECLARE_MUTEX(main_lock);
  363. /*  Private functions  */
  364. #ifdef USERSPACE_INTERFACE
  365. static void compute_ascii (void);
  366. #endif
  369. struct set_mtrr_context
  370. {
  371.     unsigned long flags;
  372.     unsigned long deftype_lo;
  373.     unsigned long deftype_hi;
  374.     unsigned long cr4val;
  375.     unsigned long ccr3;
  376. };
  378. static int arr3_protected;
  380. /*  Put the processor into a state where MTRRs can be safely set  */
  381. static void set_mtrr_prepare_save (struct set_mtrr_context *ctxt)
  382. {
  383.     /*  Disable interrupts locally  */
  384.     __save_flags (ctxt->flags); __cli ();
  386.     if ( mtrr_if != MTRR_IF_INTEL && mtrr_if != MTRR_IF_CYRIX_ARR )
  387.  return;
  389.     /*  Save value of CR4 and clear Page Global Enable (bit 7)  */
  390.     if ( test_bit(X86_FEATURE_PGE, &boot_cpu_data.x86_capability) ) {
  391. ctxt->cr4val = read_cr4();
  392. write_cr4(ctxt->cr4val & (unsigned char) ~(1<<7));
  393.     }
  395.     /*  Disable and flush caches. Note that wbinvd flushes the TLBs as
  396. a side-effect  */
  397.     {
  398. unsigned int cr0 = read_cr0() | 0x40000000;
  399. wbinvd();
  400. write_cr0( cr0 );
  401. wbinvd();
  402.     }
  404.     if ( mtrr_if == MTRR_IF_INTEL ) {
  405. /*  Save MTRR state */
  406. rdmsr (MTRRdefType_MSR, ctxt->deftype_lo, ctxt->deftype_hi);
  407.     } else {
  408. /* Cyrix ARRs - everything else were excluded at the top */
  409. ctxt->ccr3 = getCx86 (CX86_CCR3);
  410.     }
  411. }   /*  End Function set_mtrr_prepare_save  */
  413. static void set_mtrr_disable (struct set_mtrr_context *ctxt)
  414. {
  415.     if ( mtrr_if != MTRR_IF_INTEL && mtrr_if != MTRR_IF_CYRIX_ARR )
  416.  return;
  418.     if ( mtrr_if == MTRR_IF_INTEL ) {
  419. /*  Disable MTRRs, and set the default type to uncached  */
  420. wrmsr (MTRRdefType_MSR, ctxt->deftype_lo & 0xf300UL, ctxt->deftype_hi);
  421.     } else {
  422. /* Cyrix ARRs - everything else were excluded at the top */
  423. setCx86 (CX86_CCR3, (ctxt->ccr3 & 0x0f) | 0x10);
  424.     }
  425. }   /*  End Function set_mtrr_disable  */
  427. /*  Restore the processor after a set_mtrr_prepare  */
  428. static void set_mtrr_done (struct set_mtrr_context *ctxt)
  429. {
  430.     if ( mtrr_if != MTRR_IF_INTEL && mtrr_if != MTRR_IF_CYRIX_ARR ) {
  431.  __restore_flags (ctxt->flags);
  432.  return;
  433.     }
  435.     /*  Flush caches and TLBs  */
  436.     wbinvd();
  438.     /*  Restore MTRRdefType  */
  439.     if ( mtrr_if == MTRR_IF_INTEL ) {
  440. /* Intel (P6) standard MTRRs */
  441. wrmsr (MTRRdefType_MSR, ctxt->deftype_lo, ctxt->deftype_hi);
  442.     } else {
  443. /* Cyrix ARRs - everything else was excluded at the top */
  444. setCx86 (CX86_CCR3, ctxt->ccr3);
  445.     }
  447.     /*  Enable caches  */
  448.     write_cr0( read_cr0() & 0xbfffffff );
  450.     /*  Restore value of CR4  */
  451.     if ( test_bit(X86_FEATURE_PGE, &boot_cpu_data.x86_capability) )
  452. write_cr4(ctxt->cr4val);
  454.     /*  Re-enable interrupts locally (if enabled previously)  */
  455.     __restore_flags (ctxt->flags);
  456. }   /*  End Function set_mtrr_done  */
  458. /*  This function returns the number of variable MTRRs  */
  459. static unsigned int get_num_var_ranges (void)
  460. {
  461.     unsigned long config, dummy;
  463.     switch ( mtrr_if )
  464.     {
  465.     case MTRR_IF_INTEL:
  466. rdmsr (MTRRcap_MSR, config, dummy);
  467. return (config & 0xff);
  468.     case MTRR_IF_AMD_K6:
  469. return 2;
  470.     case MTRR_IF_CYRIX_ARR:
  471. return 8;
  472.     case MTRR_IF_CENTAUR_MCR:
  473. return 8;
  474.     default:
  475. return 0;
  476.     }
  477. }   /*  End Function get_num_var_ranges  */
  479. /*  Returns non-zero if we have the write-combining memory type  */
  480. static int have_wrcomb (void)
  481. {
  482.     unsigned long config, dummy;
  483.     struct pci_dev *dev = NULL;
  484.     
  485.    /* ServerWorks LE chipsets have problems with write-combining 
  486.       Don't allow it and leave room for other chipsets to be tagged */
  488. if ((dev = pci_find_class(PCI_CLASS_BRIDGE_HOST << 8, NULL)) != NULL) {
  489. if ((dev->vendor == PCI_VENDOR_ID_SERVERWORKS) &&
  490. (dev->device == PCI_DEVICE_ID_SERVERWORKS_LE)) {
  491. printk (KERN_INFO "mtrr: Serverworks LE detected. Write-combining disabled.n");
  492. return 0;
  493. }
  494. }
  496.     switch ( mtrr_if )
  497.     {
  498.     case MTRR_IF_INTEL:
  499. rdmsr (MTRRcap_MSR, config, dummy);
  500. return (config & (1<<10));
  501. return 1;
  502.     case MTRR_IF_AMD_K6:
  503.     case MTRR_IF_CENTAUR_MCR:
  504.     case MTRR_IF_CYRIX_ARR:
  505. return 1;
  506.     default:
  507. return 0;
  508.     }
  509. }   /*  End Function have_wrcomb  */
  511. static u32 size_or_mask, size_and_mask;
  513. static void intel_get_mtrr (unsigned int reg, unsigned long *base,
  514.     unsigned long *size, mtrr_type *type)
  515. {
  516.     unsigned long mask_lo, mask_hi, base_lo, base_hi;
  518.     rdmsr (MTRRphysMask_MSR(reg), mask_lo, mask_hi);
  519.     if ( (mask_lo & 0x800) == 0 )
  520.     {
  521. /*  Invalid (i.e. free) range  */
  522. *base = 0;
  523. *size = 0;
  524. *type = 0;
  525. return;
  526.     }
  528.     rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi);
  530.     /* Work out the shifted address mask. */
  531.     mask_lo = size_or_mask | mask_hi << (32 - PAGE_SHIFT)
  532. | mask_lo >> PAGE_SHIFT;
  534.     /* This works correctly if size is a power of two, i.e. a
  535.        contiguous range. */
  536.      *size = -mask_lo;
  537.      *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT;
  538.      *type = base_lo & 0xff;
  539. }   /*  End Function intel_get_mtrr  */
  541. static void cyrix_get_arr (unsigned int reg, unsigned long *base,
  542.    unsigned long *size, mtrr_type *type)
  543. {
  544.     unsigned long flags;
  545.     unsigned char arr, ccr3, rcr, shift;
  547.     arr = CX86_ARR_BASE + (reg << 1) + reg; /* avoid multiplication by 3 */
  549.     /* Save flags and disable interrupts */
  550.     __save_flags (flags); __cli ();
  552.     ccr3 = getCx86 (CX86_CCR3);
  553.     setCx86 (CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN */
  554.     ((unsigned char *) base)[3]  = getCx86 (arr);
  555.     ((unsigned char *) base)[2]  = getCx86 (arr+1);
  556.     ((unsigned char *) base)[1]  = getCx86 (arr+2);
  557.     rcr = getCx86(CX86_RCR_BASE + reg);
  558.     setCx86 (CX86_CCR3, ccr3); /* disable MAPEN */
  560.     /* Enable interrupts if it was enabled previously */
  561.     __restore_flags (flags);
  562.     shift = ((unsigned char *) base)[1] & 0x0f;
  563.     *base >>= PAGE_SHIFT;
  565.     /* Power of two, at least 4K on ARR0-ARR6, 256K on ARR7
  566.      * Note: shift==0xf means 4G, this is unsupported.
  567.      */
  568.     if (shift)
  569.       *size = (reg < 7 ? 0x1UL : 0x40UL) << (shift - 1);
  570.     else
  571.       *size = 0;
  573.     /* Bit 0 is Cache Enable on ARR7, Cache Disable on ARR0-ARR6 */
  574.     if (reg < 7)
  575.     {
  576. switch (rcr)
  577. {
  578.   case  1: *type = MTRR_TYPE_UNCACHABLE; break;
  579.   case  8: *type = MTRR_TYPE_WRBACK;     break;
  580.   case  9: *type = MTRR_TYPE_WRCOMB;     break;
  581.   case 24:
  582.   default: *type = MTRR_TYPE_WRTHROUGH;  break;
  583. }
  584.     } else
  585.     {
  586. switch (rcr)
  587. {
  588.   case  0: *type = MTRR_TYPE_UNCACHABLE; break;
  589.   case  8: *type = MTRR_TYPE_WRCOMB;     break;
  590.   case  9: *type = MTRR_TYPE_WRBACK;     break;
  591.   case 25:
  592.   default: *type = MTRR_TYPE_WRTHROUGH;  break;
  593. }
  594.     }
  595. }   /*  End Function cyrix_get_arr  */
  597. static void amd_get_mtrr (unsigned int reg, unsigned long *base,
  598.   unsigned long *size, mtrr_type *type)
  599. {
  600.     unsigned long low, high;
  602.     rdmsr (MSR_K6_UWCCR, low, high);
  603.     /*  Upper dword is region 1, lower is region 0  */
  604.     if (reg == 1) low = high;
  605.     /*  The base masks off on the right alignment  */
  606.     *base = (low & 0xFFFE0000) >> PAGE_SHIFT;
  607.     *type = 0;
  608.     if (low & 1) *type = MTRR_TYPE_UNCACHABLE;
  609.     if (low & 2) *type = MTRR_TYPE_WRCOMB;
  610.     if ( !(low & 3) )
  611.     {
  612. *size = 0;
  613. return;
  614.     }
  615.     /*
  616.      * This needs a little explaining. The size is stored as an
  617.      * inverted mask of bits of 128K granularity 15 bits long offset
  618.      * 2 bits
  619.      *
  620.      * So to get a size we do invert the mask and add 1 to the lowest
  621.      * mask bit (4 as its 2 bits in). This gives us a size we then shift
  622.      * to turn into 128K blocks
  623.      *
  624.      * eg 111 1111 1111 1100      is 512K
  625.      *
  626.      * invert 000 0000 0000 0011
  627.      * +1 000 0000 0000 0100
  628.      * *128K ...
  629.      */
  630.     low = (~low) & 0x1FFFC;
  631.     *size = (low + 4) << (15 - PAGE_SHIFT);
  632.     return;
  633. }   /*  End Function amd_get_mtrr  */
  635. static struct
  636. {
  637.     unsigned long high;
  638.     unsigned long low;
  639. } centaur_mcr[8];
  641. static u8 centaur_mcr_reserved;
  642. static u8 centaur_mcr_type; /* 0 for winchip, 1 for winchip2 */
  644. /*
  645.  * Report boot time MCR setups 
  646.  */
  647.  
  648. void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi)
  649. {
  650. centaur_mcr[mcr].low = lo;
  651. centaur_mcr[mcr].high = hi;
  652. }
  654. static void centaur_get_mcr (unsigned int reg, unsigned long *base,
  655.      unsigned long *size, mtrr_type *type)
  656. {
  657.     *base = centaur_mcr[reg].high >> PAGE_SHIFT;
  658.     *size = -(centaur_mcr[reg].low & 0xfffff000) >> PAGE_SHIFT;
  659.     *type = MTRR_TYPE_WRCOMB; /*  If it is there, it is write-combining  */
  660.     if(centaur_mcr_type==1 && ((centaur_mcr[reg].low&31)&2))
  661.      *type = MTRR_TYPE_UNCACHABLE;
  662.     if(centaur_mcr_type==1 && (centaur_mcr[reg].low&31)==25)
  663.      *type = MTRR_TYPE_WRBACK;
  664.     if(centaur_mcr_type==0 && (centaur_mcr[reg].low&31)==31)
  665.      *type = MTRR_TYPE_WRBACK;
  666.     
  667. }   /*  End Function centaur_get_mcr  */
  669. static void (*get_mtrr) (unsigned int reg, unsigned long *base,
  670.  unsigned long *size, mtrr_type *type);
  672. static void intel_set_mtrr_up (unsigned int reg, unsigned long base,
  673.        unsigned long size, mtrr_type type, int do_safe)
  674. /*  [SUMMARY] Set variable MTRR register on the local CPU.
  675.     <reg> The register to set.
  676.     <base> The base address of the region.
  677.     <size> The size of the region. If this is 0 the region is disabled.
  678.     <type> The type of the region.
  679.     <do_safe> If TRUE, do the change safely. If FALSE, safety measures should
  680.     be done externally.
  681.     [RETURNS] Nothing.
  682. */
  683. {
  684.     struct set_mtrr_context ctxt;
  686.     if (do_safe) {
  687. set_mtrr_prepare_save (&ctxt);
  688. set_mtrr_disable (&ctxt);
  689. }
  690.     if (size == 0)
  691.     {
  692. /* The invalid bit is kept in the mask, so we simply clear the
  693.    relevant mask register to disable a range. */
  694. wrmsr (MTRRphysMask_MSR (reg), 0, 0);
  695.     }
  696.     else
  697.     {
  698. wrmsr (MTRRphysBase_MSR (reg), base << PAGE_SHIFT | type,
  699. (base & size_and_mask) >> (32 - PAGE_SHIFT));
  700. wrmsr (MTRRphysMask_MSR (reg), -size << PAGE_SHIFT | 0x800,
  701. (-size & size_and_mask) >> (32 - PAGE_SHIFT));
  702.     }
  703.     if (do_safe) set_mtrr_done (&ctxt);
  704. }   /*  End Function intel_set_mtrr_up  */
  706. static void cyrix_set_arr_up (unsigned int reg, unsigned long base,
  707.       unsigned long size, mtrr_type type, int do_safe)
  708. {
  709.     struct set_mtrr_context ctxt;
  710.     unsigned char arr, arr_type, arr_size;
  712.     arr = CX86_ARR_BASE + (reg << 1) + reg; /* avoid multiplication by 3 */
  714.     /* count down from 32M (ARR0-ARR6) or from 2G (ARR7) */
  715.     if (reg >= 7)
  716. size >>= 6;
  718.     size &= 0x7fff; /* make sure arr_size <= 14 */
  719.     for(arr_size = 0; size; arr_size++, size >>= 1);
  721.     if (reg<7)
  722.     {
  723. switch (type) {
  724.   case MTRR_TYPE_UNCACHABLE: arr_type =  1; break;
  725.   case MTRR_TYPE_WRCOMB: arr_type =  9; break;
  726.   case MTRR_TYPE_WRTHROUGH: arr_type = 24; break;
  727.   default: arr_type =  8; break;
  728. }
  729.     }
  730.     else
  731.     {
  732. switch (type)
  733. {
  734.   case MTRR_TYPE_UNCACHABLE: arr_type =  0; break;
  735.   case MTRR_TYPE_WRCOMB: arr_type =  8; break;
  736.   case MTRR_TYPE_WRTHROUGH: arr_type = 25; break;
  737.   default: arr_type =  9; break;
  738. }
  739.     }
  741.     if (do_safe) {
  742. set_mtrr_prepare_save (&ctxt);
  743. set_mtrr_disable (&ctxt);
  744.     }
  745.     base <<= PAGE_SHIFT;
  746.     setCx86(arr,    ((unsigned char *) &base)[3]);
  747.     setCx86(arr+1,  ((unsigned char *) &base)[2]);
  748.     setCx86(arr+2, (((unsigned char *) &base)[1]) | arr_size);
  749.     setCx86(CX86_RCR_BASE + reg, arr_type);
  750.     if (do_safe) set_mtrr_done (&ctxt);
  751. }   /*  End Function cyrix_set_arr_up  */
  753. static void amd_set_mtrr_up (unsigned int reg, unsigned long base,
  754.      unsigned long size, mtrr_type type, int do_safe)
  755. /*  [SUMMARY] Set variable MTRR register on the local CPU.
  756.     <reg> The register to set.
  757.     <base> The base address of the region.
  758.     <size> The size of the region. If this is 0 the region is disabled.
  759.     <type> The type of the region.
  760.     <do_safe> If TRUE, do the change safely. If FALSE, safety measures should
  761.     be done externally.
  762.     [RETURNS] Nothing.
  763. */
  764. {
  765.     u32 regs[2];
  766.     struct set_mtrr_context ctxt;
  768.     if (do_safe) {
  769. set_mtrr_prepare_save (&ctxt);
  770. set_mtrr_disable (&ctxt);
  771.     }
  772.     /*
  773.      * Low is MTRR0 , High MTRR 1
  774.      */
  775.     rdmsr (MSR_K6_UWCCR, regs[0], regs[1]);
  776.     /*
  777.      * Blank to disable
  778.      */
  779.     if (size == 0)
  780. regs[reg] = 0;
  781.     else
  782. /* Set the register to the base, the type (off by one) and an
  783.    inverted bitmask of the size The size is the only odd
  784.    bit. We are fed say 512K We invert this and we get 111 1111
  785.    1111 1011 but if you subtract one and invert you get the   
  786.    desired 111 1111 1111 1100 mask
  788.    But ~(x - 1) == ~x + 1 == -x. Two's complement rocks!  */
  789. regs[reg] = (-size>>(15-PAGE_SHIFT) & 0x0001FFFC)
  790. | (base<<PAGE_SHIFT) | (type+1);
  792.     /*
  793.      * The writeback rule is quite specific. See the manual. Its
  794.      * disable local interrupts, write back the cache, set the mtrr
  795.      */
  796. wbinvd();
  797. wrmsr (MSR_K6_UWCCR, regs[0], regs[1]);
  798.     if (do_safe) set_mtrr_done (&ctxt);
  799. }   /*  End Function amd_set_mtrr_up  */
  802. static void centaur_set_mcr_up (unsigned int reg, unsigned long base,
  803. unsigned long size, mtrr_type type,
  804. int do_safe)
  805. {
  806.     struct set_mtrr_context ctxt;
  807.     unsigned long low, high;
  809.     if (do_safe) {
  810. set_mtrr_prepare_save (&ctxt);
  811. set_mtrr_disable (&ctxt);
  812.     }
  813.     if (size == 0)
  814.     {
  815.         /*  Disable  */
  816.         high = low = 0;
  817.     }
  818.     else
  819.     {
  820. high = base << PAGE_SHIFT;
  821. if(centaur_mcr_type == 0)
  822. low = -size << PAGE_SHIFT | 0x1f; /* only support write-combining... */
  823. else
  824. {
  825. if(type == MTRR_TYPE_UNCACHABLE)
  826. low = -size << PAGE_SHIFT | 0x02; /* NC */
  827. else
  828. low = -size << PAGE_SHIFT | 0x09; /* WWO,WC */
  829. }
  830.     }
  831.     centaur_mcr[reg].high = high;
  832.     centaur_mcr[reg].low = low;
  833.     wrmsr (MSR_IDT_MCR0 + reg, low, high);
  834.     if (do_safe) set_mtrr_done( &ctxt );
  835. }   /*  End Function centaur_set_mtrr_up  */
  837. static void (*set_mtrr_up) (unsigned int reg, unsigned long base,
  838.     unsigned long size, mtrr_type type,
  839.     int do_safe);
  841. #ifdef CONFIG_SMP
  843. struct mtrr_var_range
  844. {
  845.     unsigned long base_lo;
  846.     unsigned long base_hi;
  847.     unsigned long mask_lo;
  848.     unsigned long mask_hi;
  849. };
  852. /*  Get the MSR pair relating to a var range  */
  853. static void __init get_mtrr_var_range (unsigned int index,
  854.    struct mtrr_var_range *vr)
  855. {
  856.     rdmsr (MTRRphysBase_MSR (index), vr->base_lo, vr->base_hi);
  857.     rdmsr (MTRRphysMask_MSR (index), vr->mask_lo, vr->mask_hi);
  858. }   /*  End Function get_mtrr_var_range  */
  861. /*  Set the MSR pair relating to a var range. Returns TRUE if
  862.     changes are made  */
  863. static int __init set_mtrr_var_range_testing (unsigned int index,
  864.   struct mtrr_var_range *vr)
  865. {
  866.     unsigned int lo, hi;
  867.     int changed = FALSE;
  869.     rdmsr(MTRRphysBase_MSR(index), lo, hi);
  870.     if ( (vr->base_lo & 0xfffff0ffUL) != (lo & 0xfffff0ffUL)
  871.  || (vr->base_hi & 0xfUL) != (hi & 0xfUL) )
  872.     {
  873. wrmsr (MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
  874. changed = TRUE;
  875.     }
  877.     rdmsr (MTRRphysMask_MSR(index), lo, hi);
  879.     if ( (vr->mask_lo & 0xfffff800UL) != (lo & 0xfffff800UL)
  880.  || (vr->mask_hi & 0xfUL) != (hi & 0xfUL) )
  881.     {
  882. wrmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
  883. changed = TRUE;
  884.     }
  885.     return changed;
  886. }   /*  End Function set_mtrr_var_range_testing  */
  888. static void __init get_fixed_ranges(mtrr_type *frs)
  889. {
  890.     unsigned long *p = (unsigned long *)frs;
  891.     int i;
  893.     rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]);
  895.     for (i = 0; i < 2; i++)
  896. rdmsr(MTRRfix16K_80000_MSR + i, p[2 + i*2], p[3 + i*2]);
  897.     for (i = 0; i < 8; i++)
  898. rdmsr(MTRRfix4K_C0000_MSR + i, p[6 + i*2], p[7 + i*2]);
  899. }   /*  End Function get_fixed_ranges  */
  901. static int __init set_fixed_ranges_testing(mtrr_type *frs)
  902. {
  903.     unsigned long *p = (unsigned long *)frs;
  904.     int changed = FALSE;
  905.     int i;
  906.     unsigned long lo, hi;
  908.     rdmsr(MTRRfix64K_00000_MSR, lo, hi);
  909.     if (p[0] != lo || p[1] != hi)
  910.     {
  911. wrmsr (MTRRfix64K_00000_MSR, p[0], p[1]);
  912. changed = TRUE;
  913.     }
  915.     for (i = 0; i < 2; i++)
  916.     {
  917. rdmsr (MTRRfix16K_80000_MSR + i, lo, hi);
  918. if (p[2 + i*2] != lo || p[3 + i*2] != hi)
  919. {
  920.     wrmsr (MTRRfix16K_80000_MSR + i, p[2 + i*2], p[3 + i*2]);
  921.     changed = TRUE;
  922. }
  923.     }
  925.     for (i = 0; i < 8; i++)
  926.     {
  927. rdmsr (MTRRfix4K_C0000_MSR + i, lo, hi);
  928. if (p[6 + i*2] != lo || p[7 + i*2] != hi)
  929. {
  930.     wrmsr(MTRRfix4K_C0000_MSR + i, p[6 + i*2], p[7 + i*2]);
  931.     changed = TRUE;
  932. }
  933.     }
  934.     return changed;
  935. }   /*  End Function set_fixed_ranges_testing  */
  937. struct mtrr_state
  938. {
  939.     unsigned int num_var_ranges;
  940.     struct mtrr_var_range *var_ranges;
  941.     mtrr_type fixed_ranges[NUM_FIXED_RANGES];
  942.     unsigned char enabled;
  943.     mtrr_type def_type;
  944. };
  947. /*  Grab all of the MTRR state for this CPU into *state  */
  948. static void __init get_mtrr_state(struct mtrr_state *state)
  949. {
  950.     unsigned int nvrs, i;
  951.     struct mtrr_var_range *vrs;
  952.     unsigned long lo, dummy;
  954.     nvrs = state->num_var_ranges = get_num_var_ranges();
  955.     vrs = state->var_ranges
  956.               = kmalloc (nvrs * sizeof (struct mtrr_var_range), GFP_KERNEL);
  957.     if (vrs == NULL)
  958. nvrs = state->num_var_ranges = 0;
  960.     for (i = 0; i < nvrs; i++)
  961. get_mtrr_var_range (i, &vrs[i]);
  962.     get_fixed_ranges (state->fixed_ranges);
  964.     rdmsr (MTRRdefType_MSR, lo, dummy);
  965.     state->def_type = (lo & 0xff);
  966.     state->enabled = (lo & 0xc00) >> 10;
  967. }   /*  End Function get_mtrr_state  */
  970. /*  Free resources associated with a struct mtrr_state  */
  971. static void __init finalize_mtrr_state(struct mtrr_state *state)
  972. {
  973.     if (state->var_ranges) kfree (state->var_ranges);
  974. }   /*  End Function finalize_mtrr_state  */
  977. static unsigned long __init set_mtrr_state (struct mtrr_state *state,
  978. struct set_mtrr_context *ctxt)
  979. /*  [SUMMARY] Set the MTRR state for this CPU.
  980.     <state> The MTRR state information to read.
  981.     <ctxt> Some relevant CPU context.
  982.     [NOTE] The CPU must already be in a safe state for MTRR changes.
  983.     [RETURNS] 0 if no changes made, else a mask indication what was changed.
  984. */
  985. {
  986.     unsigned int i;
  987.     unsigned long change_mask = 0;
  989.     for (i = 0; i < state->num_var_ranges; i++)
  990. if ( set_mtrr_var_range_testing (i, &state->var_ranges[i]) )
  991.     change_mask |= MTRR_CHANGE_MASK_VARIABLE;
  993.     if ( set_fixed_ranges_testing(state->fixed_ranges) )
  994. change_mask |= MTRR_CHANGE_MASK_FIXED;
  995.     /*  Set_mtrr_restore restores the old value of MTRRdefType,
  996. so to set it we fiddle with the saved value  */
  997.     if ( (ctxt->deftype_lo & 0xff) != state->def_type
  998.  || ( (ctxt->deftype_lo & 0xc00) >> 10 ) != state->enabled)
  999.     {
  1000. ctxt->deftype_lo |= (state->def_type | state->enabled << 10);
  1001. change_mask |= MTRR_CHANGE_MASK_DEFTYPE;
  1002.     }
  1004.     return change_mask;
  1005. }   /*  End Function set_mtrr_state  */
  1008. static atomic_t undone_count;
  1009. static volatile int wait_barrier_mtrr_disable = FALSE;
  1010. static volatile int wait_barrier_execute = FALSE;
  1011. static volatile int wait_barrier_cache_enable = FALSE;
  1013. struct set_mtrr_data
  1014. {
  1015.     unsigned long smp_base;
  1016.     unsigned long smp_size;
  1017.     unsigned int smp_reg;
  1018.     mtrr_type smp_type;
  1019. };
  1021. static void ipi_handler (void *info)
  1022. /*  [SUMMARY] Synchronisation handler. Executed by "other" CPUs.
  1023.     [RETURNS] Nothing.
  1024. */
  1025. {
  1026.     struct set_mtrr_data *data = info;
  1027.     struct set_mtrr_context ctxt;
  1028.     set_mtrr_prepare_save (&ctxt);
  1029.     /*  Notify master that I've flushed and disabled my cache  */
  1030.     atomic_dec (&undone_count);
  1031.     while (wait_barrier_mtrr_disable) { rep_nop(); barrier(); }
  1032.     set_mtrr_disable (&ctxt);
  1033.     /*  Notify master that I've flushed and disabled my cache  */
  1034.     atomic_dec (&undone_count);
  1035.     while (wait_barrier_execute) { rep_nop(); barrier(); }
  1036.     /*  The master has cleared me to execute  */
  1037.     (*set_mtrr_up) (data->smp_reg, data->smp_base, data->smp_size,
  1038.     data->smp_type, FALSE);
  1039.     /*  Notify master CPU that I've executed the function  */
  1040.     atomic_dec (&undone_count);
  1041.     /*  Wait for master to clear me to enable cache and return  */
  1042.     while (wait_barrier_cache_enable) { rep_nop(); barrier(); }
  1043.     set_mtrr_done (&ctxt);
  1044. }   /*  End Function ipi_handler  */
  1046. static void set_mtrr_smp (unsigned int reg, unsigned long base,
  1047.   unsigned long size, mtrr_type type)
  1048. {
  1049.     struct set_mtrr_data data;
  1050.     struct set_mtrr_context ctxt;
  1052.     data.smp_reg = reg;
  1053.     data.smp_base = base;
  1054.     data.smp_size = size;
  1055.     data.smp_type = type;
  1056.     wait_barrier_mtrr_disable = TRUE;
  1057.     wait_barrier_execute = TRUE;
  1058.     wait_barrier_cache_enable = TRUE;
  1059.     atomic_set (&undone_count, smp_num_cpus - 1);
  1060.     /*  Start the ball rolling on other CPUs  */
  1061.     if (smp_call_function (ipi_handler, &data, 1, 0) != 0)
  1062. panic ("mtrr: timed out waiting for other CPUsn");
  1063.     /* Flush and disable the local CPU's cache */
  1064.     set_mtrr_prepare_save (&ctxt);
  1065.     /*  Wait for all other CPUs to flush and disable their caches  */
  1066.     while (atomic_read (&undone_count) > 0) { rep_nop(); barrier(); }
  1067.     /* Set up for completion wait and then release other CPUs to change MTRRs*/
  1068.     atomic_set (&undone_count, smp_num_cpus - 1);
  1069.     wait_barrier_mtrr_disable = FALSE;
  1070.     set_mtrr_disable (&ctxt);
  1072.     /*  Wait for all other CPUs to flush and disable their caches  */
  1073.     while (atomic_read (&undone_count) > 0) { rep_nop(); barrier(); }
  1074.     /* Set up for completion wait and then release other CPUs to change MTRRs*/
  1075.     atomic_set (&undone_count, smp_num_cpus - 1);
  1076.     wait_barrier_execute = FALSE;
  1077.     (*set_mtrr_up) (reg, base, size, type, FALSE);
  1078.     /*  Now wait for other CPUs to complete the function  */
  1079.     while (atomic_read (&undone_count) > 0) { rep_nop(); barrier(); }
  1080.     /*  Now all CPUs should have finished the function. Release the barrier to
  1081. allow them to re-enable their caches and return from their interrupt,
  1082. then enable the local cache and return  */
  1083.     wait_barrier_cache_enable = FALSE;
  1084.     set_mtrr_done (&ctxt);
  1085. }   /*  End Function set_mtrr_smp  */
  1088. /*  Some BIOS's are fucked and don't set all MTRRs the same!  */
  1089. static void __init mtrr_state_warn(unsigned long mask)
  1090. {
  1091.     if (!mask) return;
  1092.     if (mask & MTRR_CHANGE_MASK_FIXED)
  1093. printk ("mtrr: your CPUs had inconsistent fixed MTRR settingsn");
  1094.     if (mask & MTRR_CHANGE_MASK_VARIABLE)
  1095. printk ("mtrr: your CPUs had inconsistent variable MTRR settingsn");
  1096.     if (mask & MTRR_CHANGE_MASK_DEFTYPE)
  1097. printk ("mtrr: your CPUs had inconsistent MTRRdefType settingsn");
  1098.     printk ("mtrr: probably your BIOS does not setup all CPUsn");
  1099. }   /*  End Function mtrr_state_warn  */
  1101. #endif  /*  CONFIG_SMP  */
  1103. static char *attrib_to_str (int x)
  1104. {
  1105.     return (x <= 6) ? mtrr_strings[x] : "?";
  1106. }   /*  End Function attrib_to_str  */
  1108. static void init_table (void)
  1109. {
  1110.     int i, max;
  1112.     max = get_num_var_ranges ();
  1113.     if ( ( usage_table = kmalloc (max * sizeof *usage_table, GFP_KERNEL) )
  1114.  == NULL )
  1115.     {
  1116. printk ("mtrr: could not allocaten");
  1117. return;
  1118.     }
  1119.     for (i = 0; i < max; i++) usage_table[i] = 1;
  1120. #ifdef USERSPACE_INTERFACE
  1121.     if ( ( ascii_buffer = kmalloc (max * LINE_SIZE, GFP_KERNEL) ) == NULL )
  1122.     {
  1123. printk ("mtrr: could not allocaten");
  1124. return;
  1125.     }
  1126.     ascii_buf_bytes = 0;
  1127.     compute_ascii ();
  1128. #endif
  1129. }   /*  End Function init_table  */
  1131. static int generic_get_free_region (unsigned long base, unsigned long size)
  1132. /*  [SUMMARY] Get a free MTRR.
  1133.     <base> The starting (base) address of the region.
  1134.     <size> The size (in bytes) of the region.
  1135.     [RETURNS] The index of the region on success, else -1 on error.
  1136. */
  1137. {
  1138.     int i, max;
  1139.     mtrr_type ltype;
  1140.     unsigned long lbase, lsize;
  1142.     max = get_num_var_ranges ();
  1143.     for (i = 0; i < max; ++i)
  1144.     {
  1145. (*get_mtrr) (i, &lbase, &lsize, &ltype);
  1146. if (lsize == 0) return i;
  1147.     }
  1148.     return -ENOSPC;
  1149. }   /*  End Function generic_get_free_region  */
  1151. static int centaur_get_free_region (unsigned long base, unsigned long size)
  1152. /*  [SUMMARY] Get a free MTRR.
  1153.     <base> The starting (base) address of the region.
  1154.     <size> The size (in bytes) of the region.
  1155.     [RETURNS] The index of the region on success, else -1 on error.
  1156. */
  1157. {
  1158.     int i, max;
  1159.     mtrr_type ltype;
  1160.     unsigned long lbase, lsize;
  1162.     max = get_num_var_ranges ();
  1163.     for (i = 0; i < max; ++i)
  1164.     {
  1165.      if(centaur_mcr_reserved & (1<<i))
  1166.      continue;
  1167. (*get_mtrr) (i, &lbase, &lsize, &ltype);
  1168. if (lsize == 0) return i;
  1169.     }
  1170.     return -ENOSPC;
  1171. }   /*  End Function generic_get_free_region  */
  1173. static int cyrix_get_free_region (unsigned long base, unsigned long size)
  1174. /*  [SUMMARY] Get a free ARR.
  1175.     <base> The starting (base) address of the region.
  1176.     <size> The size (in bytes) of the region.
  1177.     [RETURNS] The index of the region on success, else -1 on error.
  1178. */
  1179. {
  1180.     int i;
  1181.     mtrr_type ltype;
  1182.     unsigned long lbase, lsize;
  1184.     /* If we are to set up a region >32M then look at ARR7 immediately */
  1185.     if (size > 0x2000)
  1186.     {
  1187. cyrix_get_arr (7, &lbase, &lsize, &ltype);
  1188. if (lsize == 0) return 7;
  1189. /*  Else try ARR0-ARR6 first  */
  1190.     }
  1191.     else
  1192.     {
  1193. for (i = 0; i < 7; i++)
  1194. {
  1195.     cyrix_get_arr (i, &lbase, &lsize, &ltype);
  1196.     if ((i == 3) && arr3_protected) continue;
  1197.     if (lsize == 0) return i;
  1198. }
  1199. /* ARR0-ARR6 isn't free, try ARR7 but its size must be at least 256K */
  1200. cyrix_get_arr (i, &lbase, &lsize, &ltype);
  1201. if ((lsize == 0) && (size >= 0x40)) return i;
  1202.     }
  1203.     return -ENOSPC;
  1204. }   /*  End Function cyrix_get_free_region  */
  1206. static int (*get_free_region) (unsigned long base,
  1207.        unsigned long size) = generic_get_free_region;
  1209. /**
  1210.  * mtrr_add_page - Add a memory type region
  1211.  * @base: Physical base address of region in pages (4 KB)
  1212.  * @size: Physical size of region in pages (4 KB)
  1213.  * @type: Type of MTRR desired
  1214.  * @increment: If this is true do usage counting on the region
  1215.  *
  1216.  * Memory type region registers control the caching on newer Intel and
  1217.  * non Intel processors. This function allows drivers to request an
  1218.  * MTRR is added. The details and hardware specifics of each processor's
  1219.  * implementation are hidden from the caller, but nevertheless the 
  1220.  * caller should expect to need to provide a power of two size on an
  1221.  * equivalent power of two boundary.
  1222.  *
  1223.  * If the region cannot be added either because all regions are in use
  1224.  * or the CPU cannot support it a negative value is returned. On success
  1225.  * the register number for this entry is returned, but should be treated
  1226.  * as a cookie only.
  1227.  *
  1228.  * On a multiprocessor machine the changes are made to all processors.
  1229.  * This is required on x86 by the Intel processors.
  1230.  *
  1231.  * The available types are
  1232.  *
  1233.  * %MTRR_TYPE_UNCACHABLE - No caching
  1234.  *
  1235.  * %MTRR_TYPE_WRBACK - Write data back in bursts whenever
  1236.  *
  1237.  * %MTRR_TYPE_WRCOMB - Write data back soon but allow bursts
  1238.  *
  1239.  * %MTRR_TYPE_WRTHROUGH - Cache reads but not writes
  1240.  *
  1241.  * BUGS: Needs a quiet flag for the cases where drivers do not mind
  1242.  * failures and do not wish system log messages to be sent.
  1243.  */
  1245. int mtrr_add_page(unsigned long base, unsigned long size, unsigned int type, char increment)
  1246. {
  1247. /*  [SUMMARY] Add an MTRR entry.
  1248.     <base> The starting (base, in pages) address of the region.
  1249.     <size> The size of the region. (in pages)
  1250.     <type> The type of the new region.
  1251.     <increment> If true and the region already exists, the usage count will be
  1252.     incremented.
  1253.     [RETURNS] The MTRR register on success, else a negative number indicating
  1254.     the error code.
  1255.     [NOTE] This routine uses a spinlock.
  1256. */
  1257.     int i, max;
  1258.     mtrr_type ltype;
  1259.     unsigned long lbase, lsize, last;
  1261.     switch ( mtrr_if )
  1262.     {
  1263.     case MTRR_IF_NONE:
  1264. return -ENXIO; /* No MTRRs whatsoever */
  1266.     case MTRR_IF_AMD_K6:
  1267. /* Apply the K6 block alignment and size rules
  1268.    In order
  1269.    o Uncached or gathering only
  1270.    o 128K or bigger block
  1271.    o Power of 2 block
  1272.    o base suitably aligned to the power
  1273. */
  1274. if ( type > MTRR_TYPE_WRCOMB || size < (1 << (17-PAGE_SHIFT)) ||
  1275.      (size & ~(size-1))-size || ( base & (size-1) ) )
  1276.     return -EINVAL;
  1277. break;
  1279.     case MTRR_IF_INTEL:
  1280. /*  For Intel PPro stepping <= 7, must be 4 MiB aligned 
  1281.     and not touch 0x70000000->0x7003FFFF */
  1282. if ( boot_cpu_data.x86_vendor == X86_VENDOR_INTEL &&
  1283.      boot_cpu_data.x86 == 6 &&
  1284.      boot_cpu_data.x86_model == 1 &&
  1285.      boot_cpu_data.x86_mask <= 7 )
  1286. {
  1287.     if ( base & ((1 << (22-PAGE_SHIFT))-1) )
  1288.     {
  1289. printk (KERN_WARNING "mtrr: base(0x%lx000) is not 4 MiB alignedn", base);
  1290. return -EINVAL;
  1291.     }
  1292.     if (!(base + size < 0x70000000 || base > 0x7003FFFF) &&
  1293.  (type == MTRR_TYPE_WRCOMB || type == MTRR_TYPE_WRBACK))
  1294.     {
  1295. printk (KERN_WARNING "mtrr: writable mtrr between 0x70000000 and 0x7003FFFF may hang the CPU.n");
  1296.         return -EINVAL;
  1297.     }
  1298. }
  1299. /* Fall through */
  1301.     case MTRR_IF_CYRIX_ARR:
  1302.     case MTRR_IF_CENTAUR_MCR:
  1303.         if ( mtrr_if == MTRR_IF_CENTAUR_MCR )
  1304. {
  1305.     /*
  1306.      * FIXME: Winchip2 supports uncached
  1307.      */
  1308.     if (type != MTRR_TYPE_WRCOMB && (centaur_mcr_type == 0 || type != MTRR_TYPE_UNCACHABLE))
  1309.     {
  1310. printk (KERN_WARNING "mtrr: only write-combining%s supportedn",
  1311. centaur_mcr_type?" and uncacheable are":" is");
  1312. return -EINVAL;
  1313.     }
  1314. }
  1315. else if (base + size < 0x100)
  1316. {
  1317.     printk (KERN_WARNING "mtrr: cannot set region below 1 MiB (0x%lx000,0x%lx000)n",
  1318.     base, size);
  1319.     return -EINVAL;
  1320. }
  1321. /*  Check upper bits of base and last are equal and lower bits are 0
  1322.     for base and 1 for last  */
  1323. last = base + size - 1;
  1324. for (lbase = base; !(lbase & 1) && (last & 1);
  1325.      lbase = lbase >> 1, last = last >> 1);
  1326. if (lbase != last)
  1327. {
  1328.     printk (KERN_WARNING "mtrr: base(0x%lx000) is not aligned on a size(0x%lx000) boundaryn",
  1329.     base, size);
  1330.     return -EINVAL;
  1331. }
  1332. break;
  1334.     default:
  1335. return -EINVAL;
  1336.     }
  1338.     if (type >= MTRR_NUM_TYPES)
  1339.     {
  1340. printk ("mtrr: type: %u illegaln", type);
  1341. return -EINVAL;
  1342.     }
  1344.     /*  If the type is WC, check that this processor supports it  */
  1345.     if ( (type == MTRR_TYPE_WRCOMB) && !have_wrcomb () )
  1346.     {
  1347.         printk (KERN_WARNING "mtrr: your processor doesn't support write-combiningn");
  1348.         return -ENOSYS;
  1349.     }
  1351.     if ( base & size_or_mask || size  & size_or_mask )
  1352.     {
  1353. printk ("mtrr: base or size exceeds the MTRR widthn");
  1354. return -EINVAL;
  1355.     }
  1357.     increment = increment ? 1 : 0;
  1358.     max = get_num_var_ranges ();
  1359.     /*  Search for existing MTRR  */
  1360.     down(&main_lock);
  1361.     for (i = 0; i < max; ++i)
  1362.     {
  1363. (*get_mtrr) (i, &lbase, &lsize, &ltype);
  1364. if (base >= lbase + lsize) continue;
  1365. if ( (base < lbase) && (base + size <= lbase) ) continue;
  1366. /*  At this point we know there is some kind of overlap/enclosure  */
  1367. if ( (base < lbase) || (base + size > lbase + lsize) )
  1368. {
  1369.     up(&main_lock);
  1370.     printk (KERN_WARNING "mtrr: 0x%lx000,0x%lx000 overlaps existing"
  1371.     " 0x%lx000,0x%lx000n",
  1372.     base, size, lbase, lsize);
  1373.     return -EINVAL;
  1374. }
  1375. /*  New region is enclosed by an existing region  */
  1376. if (ltype != type)
  1377. {
  1378.     if (type == MTRR_TYPE_UNCACHABLE) continue;
  1379.     up(&main_lock);
  1380.     printk ( "mtrr: type mismatch for %lx000,%lx000 old: %s new: %sn",
  1381.      base, size, attrib_to_str (ltype), attrib_to_str (type) );
  1382.     return -EINVAL;
  1383. }
  1384. if (increment) ++usage_table[i];
  1385. compute_ascii ();
  1386. up(&main_lock);
  1387. return i;
  1388.     }
  1389.     /*  Search for an empty MTRR  */
  1390.     i = (*get_free_region) (base, size);
  1391.     if (i < 0)
  1392.     {
  1393. up(&main_lock);
  1394. printk ("mtrr: no more MTRRs availablen");
  1395. return i;
  1396.     }
  1397.     set_mtrr (i, base, size, type);
  1398.     usage_table[i] = 1;
  1399.     compute_ascii ();
  1400.     up(&main_lock);
  1401.     return i;
  1402. }   /*  End Function mtrr_add_page  */
  1404. /**
  1405.  * mtrr_add - Add a memory type region
  1406.  * @base: Physical base address of region
  1407.  * @size: Physical size of region
  1408.  * @type: Type of MTRR desired
  1409.  * @increment: If this is true do usage counting on the region
  1410.  *
  1411.  * Memory type region registers control the caching on newer Intel and
  1412.  * non Intel processors. This function allows drivers to request an
  1413.  * MTRR is added. The details and hardware specifics of each processor's
  1414.  * implementation are hidden from the caller, but nevertheless the 
  1415.  * caller should expect to need to provide a power of two size on an
  1416.  * equivalent power of two boundary.
  1417.  *
  1418.  * If the region cannot be added either because all regions are in use
  1419.  * or the CPU cannot support it a negative value is returned. On success
  1420.  * the register number for this entry is returned, but should be treated
  1421.  * as a cookie only.
  1422.  *
  1423.  * On a multiprocessor machine the changes are made to all processors.
  1424.  * This is required on x86 by the Intel processors.
  1425.  *
  1426.  * The available types are
  1427.  *
  1428.  * %MTRR_TYPE_UNCACHABLE - No caching
  1429.  *
  1430.  * %MTRR_TYPE_WRBACK - Write data back in bursts whenever
  1431.  *
  1432.  * %MTRR_TYPE_WRCOMB - Write data back soon but allow bursts
  1433.  *
  1434.  * %MTRR_TYPE_WRTHROUGH - Cache reads but not writes
  1435.  *
  1436.  * BUGS: Needs a quiet flag for the cases where drivers do not mind
  1437.  * failures and do not wish system log messages to be sent.
  1438.  */
  1440. int mtrr_add(unsigned long base, unsigned long size, unsigned int type, char increment)
  1441. {
  1442. /*  [SUMMARY] Add an MTRR entry.
  1443.     <base> The starting (base) address of the region.
  1444.     <size> The size (in bytes) of the region.
  1445.     <type> The type of the new region.
  1446.     <increment> If true and the region already exists, the usage count will be
  1447.     incremented.
  1448.     [RETURNS] The MTRR register on success, else a negative number indicating
  1449.     the error code.
  1450. */
  1452.     if ( (base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)) )
  1453.     {
  1454. printk ("mtrr: size and base must be multiples of 4 kiBn");
  1455. printk ("mtrr: size: 0x%lx  base: 0x%lxn", size, base);
  1456. return -EINVAL;
  1457.     }
  1458.     return mtrr_add_page(base >> PAGE_SHIFT, size >> PAGE_SHIFT, type, increment);
  1459. }   /*  End Function mtrr_add  */
  1461. /**
  1462.  * mtrr_del_page - delete a memory type region
  1463.  * @reg: Register returned by mtrr_add
  1464.  * @base: Physical base address
  1465.  * @size: Size of region
  1466.  *
  1467.  * If register is supplied then base and size are ignored. This is
  1468.  * how drivers should call it.
  1469.  *
  1470.  * Releases an MTRR region. If the usage count drops to zero the 
  1471.  * register is freed and the region returns to default state.
  1472.  * On success the register is returned, on failure a negative error
  1473.  * code.
  1474.  */
  1475.  
  1476. int mtrr_del_page (int reg, unsigned long base, unsigned long size)
  1477. /*  [SUMMARY] Delete MTRR/decrement usage count.
  1478.     <reg> The register. If this is less than 0 then <<base>> and <<size>> must
  1479.     be supplied.
  1480.     <base> The base address of the region. This is ignored if <<reg>> is >= 0.
  1481.     <size> The size of the region. This is ignored if <<reg>> is >= 0.
  1482.     [RETURNS] The register on success, else a negative number indicating
  1483.     the error code.
  1484.     [NOTE] This routine uses a spinlock.
  1485. */
  1486. {
  1487.     int i, max;
  1488.     mtrr_type ltype;
  1489.     unsigned long lbase, lsize;
  1491.     if ( mtrr_if == MTRR_IF_NONE ) return -ENXIO;
  1493.     max = get_num_var_ranges ();
  1494.     down (&main_lock);
  1495.     if (reg < 0)
  1496.     {
  1497. /*  Search for existing MTRR  */
  1498. for (i = 0; i < max; ++i)
  1499. {
  1500.     (*get_mtrr) (i, &lbase, &lsize, &ltype);
  1501.     if (lbase == base && lsize == size)
  1502.     {
  1503. reg = i;
  1504. break;
  1505.     }
  1506. }
  1507. if (reg < 0)
  1508. {
  1509.     up(&main_lock);
  1510.     printk ("mtrr: no MTRR for %lx000,%lx000 foundn", base, size);
  1511.     return -EINVAL;
  1512. }
  1513.     }
  1514.     if (reg >= max)
  1515.     {
  1516. up (&main_lock);
  1517. printk ("mtrr: register: %d too bign", reg);
  1518. return -EINVAL;
  1519.     }
  1520.     if ( mtrr_if == MTRR_IF_CYRIX_ARR )
  1521.     {
  1522. if ( (reg == 3) && arr3_protected )
  1523. {
  1524.     up (&main_lock);
  1525.     printk ("mtrr: ARR3 cannot be changedn");
  1526.     return -EINVAL;
  1527. }
  1528.     }
  1529.     (*get_mtrr) (reg, &lbase, &lsize, &ltype);
  1530.     if (lsize < 1)
  1531.     {
  1532. up (&main_lock);
  1533. printk ("mtrr: MTRR %d not usedn", reg);
  1534. return -EINVAL;
  1535.     }
  1536.     if (usage_table[reg] < 1)
  1537.     {
  1538. up (&main_lock);
  1539. printk ("mtrr: reg: %d has count=0n", reg);
  1540. return -EINVAL;
  1541.     }
  1542.     if (--usage_table[reg] < 1) set_mtrr (reg, 0, 0, 0);
  1543.     compute_ascii ();
  1544.     up (&main_lock);
  1545.     return reg;
  1546. }   /*  End Function mtrr_del_page  */
  1548. /**
  1549.  * mtrr_del - delete a memory type region
  1550.  * @reg: Register returned by mtrr_add
  1551.  * @base: Physical base address
  1552.  * @size: Size of region
  1553.  *
  1554.  * If register is supplied then base and size are ignored. This is
  1555.  * how drivers should call it.
  1556.  *
  1557.  * Releases an MTRR region. If the usage count drops to zero the 
  1558.  * register is freed and the region returns to default state.
  1559.  * On success the register is returned, on failure a negative error
  1560.  * code.
  1561.  */
  1562.  
  1563. int mtrr_del (int reg, unsigned long base, unsigned long size)
  1564. /*  [SUMMARY] Delete MTRR/decrement usage count.
  1565.     <reg> The register. If this is less than 0 then <<base>> and <<size>> must
  1566.     be supplied.
  1567.     <base> The base address of the region. This is ignored if <<reg>> is >= 0.
  1568.     <size> The size of the region. This is ignored if <<reg>> is >= 0.
  1569.     [RETURNS] The register on success, else a negative number indicating
  1570.     the error code.
  1571. */
  1572. {
  1573.     if ( (base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)) )
  1574.     {
  1575. printk ("mtrr: size and base must be multiples of 4 kiBn");
  1576. printk ("mtrr: size: 0x%lx  base: 0x%lxn", size, base);
  1577. return -EINVAL;
  1578.     }
  1579.     return mtrr_del_page(reg, base >> PAGE_SHIFT, size >> PAGE_SHIFT);
  1580. }
  1582. #ifdef USERSPACE_INTERFACE
  1584. static int mtrr_file_add (unsigned long base, unsigned long size,
  1585.   unsigned int type, char increment, struct file *file, int page)
  1586. {
  1587.     int reg, max;
  1588.     unsigned int *fcount = file->private_data;
  1590.     max = get_num_var_ranges ();
  1591.     if (fcount == NULL)
  1592.     {
  1593. if ( ( fcount = kmalloc (max * sizeof *fcount, GFP_KERNEL) ) == NULL )
  1594. {
  1595.     printk ("mtrr: could not allocaten");
  1596.     return -ENOMEM;
  1597. }
  1598. memset (fcount, 0, max * sizeof *fcount);
  1599. file->private_data = fcount;
  1600.     }
  1601.     if (!page) {
  1602. if ( (base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)) )
  1603. {
  1604.     printk ("mtrr: size and base must be multiples of 4 kiBn");
  1605.     printk ("mtrr: size: 0x%lx  base: 0x%lxn", size, base);
  1606.     return -EINVAL;
  1607. }
  1608. base >>= PAGE_SHIFT;
  1609. size >>= PAGE_SHIFT;
  1610.     }
  1611.     reg = mtrr_add_page (base, size, type, 1);
  1612.     if (reg >= 0) ++fcount[reg];
  1613.     return reg;
  1614. }   /*  End Function mtrr_file_add  */
  1616. static int mtrr_file_del (unsigned long base, unsigned long size,
  1617.   struct file *file, int page)
  1618. {
  1619.     int reg;
  1620.     unsigned int *fcount = file->private_data;
  1622.     if (!page) {
  1623. if ( (base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)) )
  1624. {
  1625.     printk ("mtrr: size and base must be multiples of 4 kiBn");
  1626.     printk ("mtrr: size: 0x%lx  base: 0x%lxn", size, base);
  1627.     return -EINVAL;
  1628. }
  1629. base >>= PAGE_SHIFT;
  1630. size >>= PAGE_SHIFT;
  1631.     }
  1632.     reg = mtrr_del_page (-1, base, size);
  1633.     if (reg < 0) return reg;
  1634.     if (fcount == NULL) return reg;
  1635.     if (fcount[reg] < 1) return -EINVAL;
  1636.     --fcount[reg];
  1637.     return reg;
  1638. }   /*  End Function mtrr_file_del  */
  1640. static ssize_t mtrr_read (struct file *file, char *buf, size_t len,
  1641.   loff_t *ppos)
  1642. {
  1643.     if (*ppos >= ascii_buf_bytes) return 0;
  1644.     if (*ppos + len > ascii_buf_bytes) len = ascii_buf_bytes - *ppos;
  1645.     if ( copy_to_user (buf, ascii_buffer + *ppos, len) ) return -EFAULT;
  1646.     *ppos += len;
  1647.     return len;
  1648. }   /*  End Function mtrr_read  */
  1650. static ssize_t mtrr_write (struct file *file, const char *buf, size_t len,
  1651.    loff_t *ppos)
  1652. /*  Format of control line:
  1653.     "base=%Lx size=%Lx type=%s"     OR:
  1654.     "disable=%d"
  1655. */
  1656. {
  1657.     int i, err;
  1658.     unsigned long reg;
  1659.     unsigned long long base, size;
  1660.     char *ptr;
  1661.     char line[LINE_SIZE];
  1663.     if ( !suser () ) return -EPERM;
  1664.     /*  Can't seek (pwrite) on this device  */
  1665.     if (ppos != &file->f_pos) return -ESPIPE;
  1666.     memset (line, 0, LINE_SIZE);
  1667.     if (len > LINE_SIZE) len = LINE_SIZE;
  1668.     if ( copy_from_user (line, buf, len - 1) ) return -EFAULT;
  1669.     ptr = line + strlen (line) - 1;
  1670.     if (*ptr == 'n') *ptr = '';
  1671.     if ( !strncmp (line, "disable=", 8) )
  1672.     {
  1673. reg = simple_strtoul (line + 8, &ptr, 0);
  1674. err = mtrr_del_page (reg, 0, 0);
  1675. if (err < 0) return err;
  1676. return len;
  1677.     }
  1678.     if ( strncmp (line, "base=", 5) )
  1679.     {
  1680. printk ("mtrr: no "base=" in line: "%s"n", line);
  1681. return -EINVAL;
  1682.     }
  1683.     base = simple_strtoull (line + 5, &ptr, 0);
  1684.     for (; isspace (*ptr); ++ptr);
  1685.     if ( strncmp (ptr, "size=", 5) )
  1686.     {
  1687. printk ("mtrr: no "size=" in line: "%s"n", line);
  1688. return -EINVAL;
  1689.     }
  1690.     size = simple_strtoull (ptr + 5, &ptr, 0);
  1691.     if ( (base & 0xfff) || (size & 0xfff) )
  1692.     {
  1693. printk ("mtrr: size and base must be multiples of 4 kiBn");
  1694. printk ("mtrr: size: 0x%Lx  base: 0x%Lxn", size, base);
  1695. return -EINVAL;
  1696.     }
  1697.     for (; isspace (*ptr); ++ptr);
  1698.     if ( strncmp (ptr, "type=", 5) )
  1699.     {
  1700. printk ("mtrr: no "type=" in line: "%s"n", line);
  1701. return -EINVAL;
  1702.     }
  1703.     ptr += 5;
  1704.     for (; isspace (*ptr); ++ptr);
  1705.     for (i = 0; i < MTRR_NUM_TYPES; ++i)
  1706.     {
  1707. if ( strcmp (ptr, mtrr_strings[i]) ) continue;
  1708. base >>= PAGE_SHIFT;
  1709. size >>= PAGE_SHIFT;
  1710. err = mtrr_add_page ((unsigned long)base, (unsigned long)size, i, 1);
  1711. if (err < 0) return err;
  1712. return len;
  1713.     }
  1714.     printk ("mtrr: illegal type: "%s"n", ptr);
  1715.     return -EINVAL;
  1716. }   /*  End Function mtrr_write  */
  1718. static int mtrr_ioctl (struct inode *inode, struct file *file,
  1719.        unsigned int cmd, unsigned long arg)
  1720. {
  1721.     int err;
  1722.     mtrr_type type;
  1723.     struct mtrr_sentry sentry;
  1724.     struct mtrr_gentry gentry;
  1726.     switch (cmd)
  1727.     {
  1728.       default:
  1729. return -ENOIOCTLCMD;
  1730.       case MTRRIOC_ADD_ENTRY:
  1731. if ( !suser () ) return -EPERM;
  1732. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1733.     return -EFAULT;
  1734. err = mtrr_file_add (sentry.base, sentry.size, sentry.type, 1, file, 0);
  1735. if (err < 0) return err;
  1736. break;
  1737.       case MTRRIOC_SET_ENTRY:
  1738. if ( !suser () ) return -EPERM;
  1739. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1740.     return -EFAULT;
  1741. err = mtrr_add (sentry.base, sentry.size, sentry.type, 0);
  1742. if (err < 0) return err;
  1743. break;
  1744.       case MTRRIOC_DEL_ENTRY:
  1745. if ( !suser () ) return -EPERM;
  1746. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1747.     return -EFAULT;
  1748. err = mtrr_file_del (sentry.base, sentry.size, file, 0);
  1749. if (err < 0) return err;
  1750. break;
  1751.       case MTRRIOC_KILL_ENTRY:
  1752. if ( !suser () ) return -EPERM;
  1753. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1754.     return -EFAULT;
  1755. err = mtrr_del (-1, sentry.base, sentry.size);
  1756. if (err < 0) return err;
  1757. break;
  1758.       case MTRRIOC_GET_ENTRY:
  1759. if ( copy_from_user (&gentry, (void *) arg, sizeof gentry) )
  1760.     return -EFAULT;
  1761. if ( gentry.regnum >= get_num_var_ranges () ) return -EINVAL;
  1762. (*get_mtrr) (gentry.regnum, &gentry.base, &gentry.size, &type);
  1764. /* Hide entries that go above 4GB */
  1765. if (gentry.base + gentry.size > 0x100000 || gentry.size == 0x100000)
  1766.     gentry.base = gentry.size = gentry.type = 0;
  1767. else {
  1768.     gentry.base <<= PAGE_SHIFT;
  1769.     gentry.size <<= PAGE_SHIFT;
  1770.     gentry.type = type;
  1771. }
  1773. if ( copy_to_user ( (void *) arg, &gentry, sizeof gentry) )
  1774.      return -EFAULT;
  1775. break;
  1776.       case MTRRIOC_ADD_PAGE_ENTRY:
  1777. if ( !suser () ) return -EPERM;
  1778. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1779.     return -EFAULT;
  1780. err = mtrr_file_add (sentry.base, sentry.size, sentry.type, 1, file, 1);
  1781. if (err < 0) return err;
  1782. break;
  1783.       case MTRRIOC_SET_PAGE_ENTRY:
  1784. if ( !suser () ) return -EPERM;
  1785. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1786.     return -EFAULT;
  1787. err = mtrr_add_page (sentry.base, sentry.size, sentry.type, 0);
  1788. if (err < 0) return err;
  1789. break;
  1790.       case MTRRIOC_DEL_PAGE_ENTRY:
  1791. if ( !suser () ) return -EPERM;
  1792. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1793.     return -EFAULT;
  1794. err = mtrr_file_del (sentry.base, sentry.size, file, 1);
  1795. if (err < 0) return err;
  1796. break;
  1797.       case MTRRIOC_KILL_PAGE_ENTRY:
  1798. if ( !suser () ) return -EPERM;
  1799. if ( copy_from_user (&sentry, (void *) arg, sizeof sentry) )
  1800.     return -EFAULT;
  1801. err = mtrr_del_page (-1, sentry.base, sentry.size);
  1802. if (err < 0) return err;
  1803. break;
  1804.       case MTRRIOC_GET_PAGE_ENTRY:
  1805. if ( copy_from_user (&gentry, (void *) arg, sizeof gentry) )
  1806.     return -EFAULT;
  1807. if ( gentry.regnum >= get_num_var_ranges () ) return -EINVAL;
  1808. (*get_mtrr) (gentry.regnum, &gentry.base, &gentry.size, &type);
  1809. gentry.type = type;
  1811. if ( copy_to_user ( (void *) arg, &gentry, sizeof gentry) )
  1812.      return -EFAULT;
  1813. break;
  1814.     }
  1815.     return 0;
  1816. }   /*  End Function mtrr_ioctl  */
  1818. static int mtrr_close (struct inode *ino, struct file *file)
  1819. {
  1820.     int i, max;
  1821.     unsigned int *fcount = file->private_data;
  1823.     if (fcount == NULL) return 0;
  1824.     lock_kernel();
  1825.     max = get_num_var_ranges ();
  1826.     for (i = 0; i < max; ++i)
  1827.     {
  1828. while (fcount[i] > 0)
  1829. {
  1830.     if (mtrr_del (i, 0, 0) < 0) printk ("mtrr: reg %d not usedn", i);
  1831.     --fcount[i];
  1832. }
  1833.     }
  1834.     unlock_kernel();
  1835.     kfree (fcount);
  1836.     file->private_data = NULL;
  1837.     return 0;
  1838. }   /*  End Function mtrr_close  */
  1840. static struct file_operations mtrr_fops =
  1841. {
  1842.     owner: THIS_MODULE,
  1843.     read: mtrr_read,
  1844.     write: mtrr_write,
  1845.     ioctl: mtrr_ioctl,
  1846.     release: mtrr_close,
  1847. };
  1849. #  ifdef CONFIG_PROC_FS
  1851. static struct proc_dir_entry *proc_root_mtrr;
  1853. #  endif  /*  CONFIG_PROC_FS  */
  1855. static devfs_handle_t devfs_handle;
  1857. static void compute_ascii (void)
  1858. {
  1859.     char factor;
  1860.     int i, max;
  1861.     mtrr_type type;
  1862.     unsigned long base, size;
  1864.     ascii_buf_bytes = 0;
  1865.     max = get_num_var_ranges ();
  1866.     for (i = 0; i < max; i++)
  1867.     {
  1868. (*get_mtrr) (i, &base, &size, &type);
  1869. if (size == 0) usage_table[i] = 0;
  1870. else
  1871. {
  1872.     if (size < (0x100000 >> PAGE_SHIFT))
  1873.     {
  1874. /* less than 1MB */
  1875. factor = 'K';
  1876. size <<= PAGE_SHIFT - 10;
  1877.     }
  1878.     else
  1879.     {
  1880. factor = 'M';
  1881. size >>= 20 - PAGE_SHIFT;
  1882.     }
  1883.     sprintf
  1884. (ascii_buffer + ascii_buf_bytes,
  1885.  "reg%02i: base=0x%05lx000 (%4liMB), size=%4li%cB: %s, count=%dn",
  1886.  i, base, base >> (20 - PAGE_SHIFT), size, factor,
  1887.  attrib_to_str (type), usage_table[i]);
  1888.     ascii_buf_bytes += strlen (ascii_buffer + ascii_buf_bytes);
  1889. }
  1890.     }
  1891.     devfs_set_file_size (devfs_handle, ascii_buf_bytes);
  1892. #  ifdef CONFIG_PROC_FS
  1893.     if (proc_root_mtrr)
  1894. proc_root_mtrr->size = ascii_buf_bytes;
  1895. #  endif  /*  CONFIG_PROC_FS  */
  1896. }   /*  End Function compute_ascii  */
  1898. #endif  /*  USERSPACE_INTERFACE  */
  1900. EXPORT_SYMBOL(mtrr_add);
  1901. EXPORT_SYMBOL(mtrr_del);
  1903. #ifdef CONFIG_SMP
  1905. typedef struct
  1906. {
  1907.     unsigned long base;
  1908.     unsigned long size;
  1909.     mtrr_type type;
  1910. } arr_state_t;
  1912. arr_state_t arr_state[8] __initdata =
  1913. {
  1914.     {0UL,0UL,0UL}, {0UL,0UL,0UL}, {0UL,0UL,0UL}, {0UL,0UL,0UL},
  1915.     {0UL,0UL,0UL}, {0UL,0UL,0UL}, {0UL,0UL,0UL}, {0UL,0UL,0UL}
  1916. };
  1918. unsigned char ccr_state[7] __initdata = { 0, 0, 0, 0, 0, 0, 0 };
  1920. static void __init cyrix_arr_init_secondary(void)
  1921. {
  1922.     struct set_mtrr_context ctxt;
  1923.     int i;
  1925.     /* flush cache and enable MAPEN */
  1926.     set_mtrr_prepare_save (&ctxt);
  1927.     set_mtrr_disable (&ctxt);
  1929.      /* the CCRs are not contiguous */
  1930.     for(i=0; i<4; i++) setCx86(CX86_CCR0 + i, ccr_state[i]);
  1931.     for(   ; i<7; i++) setCx86(CX86_CCR4 + i, ccr_state[i]);
  1932.     for(i=0; i<8; i++)
  1933.       cyrix_set_arr_up(i,
  1934.         arr_state[i].base, arr_state[i].size, arr_state[i].type, FALSE);
  1936.     set_mtrr_done (&ctxt); /* flush cache and disable MAPEN */
  1937. }   /*  End Function cyrix_arr_init_secondary  */
  1939. #endif
  1941. /*
  1942.  * On Cyrix 6x86(MX) and M II the ARR3 is special: it has connection
  1943.  * with the SMM (System Management Mode) mode. So we need the following:
  1944.  * Check whether SMI_LOCK (CCR3 bit 0) is set
  1945.  *   if it is set, write a warning message: ARR3 cannot be changed!
  1946.  *     (it cannot be changed until the next processor reset)
  1947.  *   if it is reset, then we can change it, set all the needed bits:
  1948.  *   - disable access to SMM memory through ARR3 range (CCR1 bit 7 reset)
  1949.  *   - disable access to SMM memory (CCR1 bit 2 reset)
  1950.  *   - disable SMM mode (CCR1 bit 1 reset)
  1951.  *   - disable write protection of ARR3 (CCR6 bit 1 reset)
  1952.  *   - (maybe) disable ARR3
  1953.  * Just to be sure, we enable ARR usage by the processor (CCR5 bit 5 set)
  1954.  */
  1955. static void __init cyrix_arr_init(void)
  1956. {
  1957.     struct set_mtrr_context ctxt;
  1958.     unsigned char ccr[7];
  1959.     int ccrc[7] = { 0, 0, 0, 0, 0, 0, 0 };
  1960. #ifdef CONFIG_SMP
  1961.     int i;
  1962. #endif
  1964.     /* flush cache and enable MAPEN */
  1965.     set_mtrr_prepare_save (&ctxt);
  1966.     set_mtrr_disable (&ctxt);
  1968.     /* Save all CCRs locally */
  1969.     ccr[0] = getCx86 (CX86_CCR0);
  1970.     ccr[1] = getCx86 (CX86_CCR1);
  1971.     ccr[2] = getCx86 (CX86_CCR2);
  1972.     ccr[3] = ctxt.ccr3;
  1973.     ccr[4] = getCx86 (CX86_CCR4);
  1974.     ccr[5] = getCx86 (CX86_CCR5);
  1975.     ccr[6] = getCx86 (CX86_CCR6);
  1977.     if (ccr[3] & 1)
  1978.     {
  1979. ccrc[3] = 1;
  1980. arr3_protected = 1;
  1981.     }
  1982.     else
  1983.     {
  1984. /* Disable SMM mode (bit 1), access to SMM memory (bit 2) and
  1985.  * access to SMM memory through ARR3 (bit 7).
  1986.  */
  1987. if (ccr[1] & 0x80) { ccr[1] &= 0x7f; ccrc[1] |= 0x80; }
  1988. if (ccr[1] & 0x04) { ccr[1] &= 0xfb; ccrc[1] |= 0x04; }
  1989. if (ccr[1] & 0x02) { ccr[1] &= 0xfd; ccrc[1] |= 0x02; }
  1990. arr3_protected = 0;
  1991. if (ccr[6] & 0x02) {
  1992.     ccr[6] &= 0xfd; ccrc[6] = 1; /* Disable write protection of ARR3 */
  1993.     setCx86 (CX86_CCR6, ccr[6]);
  1994. }
  1995. /* Disable ARR3. This is safe now that we disabled SMM. */
  1996. /* cyrix_set_arr_up (3, 0, 0, 0, FALSE); */
  1997.     }
  1998.     /* If we changed CCR1 in memory, change it in the processor, too. */
  1999.     if (ccrc[1]) setCx86 (CX86_CCR1, ccr[1]);
  2001.     /* Enable ARR usage by the processor */
  2002.     if (!(ccr[5] & 0x20))
  2003.     {
  2004. ccr[5] |= 0x20; ccrc[5] = 1;
  2005. setCx86 (CX86_CCR5, ccr[5]);
  2006.     }
  2008. #ifdef CONFIG_SMP
  2009.     for(i=0; i<7; i++) ccr_state[i] = ccr[i];
  2010.     for(i=0; i<8; i++)
  2011.       cyrix_get_arr(i,
  2012.         &arr_state[i].base, &arr_state[i].size, &arr_state[i].type);
  2013. #endif
  2015.     set_mtrr_done (&ctxt); /* flush cache and disable MAPEN */
  2017.     if ( ccrc[5] ) printk ("mtrr: ARR usage was not enabled, enabled manuallyn");
  2018.     if ( ccrc[3] ) printk ("mtrr: ARR3 cannot be changedn");
  2019. /*
  2020.     if ( ccrc[1] & 0x80) printk ("mtrr: SMM memory access through ARR3 disabledn");
  2021.     if ( ccrc[1] & 0x04) printk ("mtrr: SMM memory access disabledn");
  2022.     if ( ccrc[1] & 0x02) printk ("mtrr: SMM mode disabledn");
  2023. */
  2024.     if ( ccrc[6] ) printk ("mtrr: ARR3 was write protected, unprotectedn");
  2025. }   /*  End Function cyrix_arr_init  */
  2027. /*
  2028.  * Initialise the later (saner) Winchip MCR variant. In this version
  2029.  * the BIOS can pass us the registers it has used (but not their values)
  2030.  * and the control register is read/write
  2031.  */
  2032.  
  2033. static void __init centaur_mcr1_init(void)
  2034. {
  2035.     unsigned i;
  2036.     u32 lo, hi;
  2038.     /* Unfortunately, MCR's are read-only, so there is no way to
  2039.      * find out what the bios might have done.
  2040.      */
  2041.      
  2042.     rdmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2043.     if(((lo>>17)&7)==1) /* Type 1 Winchip2 MCR */
  2044.     {
  2045.      lo&= ~0x1C0; /* clear key */
  2046.      lo|= 0x040; /* set key to 1 */
  2047. wrmsr(MSR_IDT_MCR_CTRL, lo, hi); /* unlock MCR */
  2048.     }    
  2049.     
  2050.     centaur_mcr_type = 1;
  2051.     
  2052.     /*
  2053.      * Clear any unconfigured MCR's.
  2054.      */
  2056.     for (i = 0; i < 8; ++i)
  2057.     {
  2058.      if(centaur_mcr[i]. high == 0 && centaur_mcr[i].low == 0)
  2059.      {
  2060.      if(!(lo & (1<<(9+i))))
  2061. wrmsr (MSR_IDT_MCR0 + i , 0, 0);
  2062. else
  2063. /*
  2064.  * If the BIOS set up an MCR we cannot see it
  2065.  * but we don't wish to obliterate it
  2066.  */
  2067. centaur_mcr_reserved |= (1<<i);
  2068. }
  2069.     }
  2070.     /*  
  2071.      * Throw the main write-combining switch... 
  2072.      * However if OOSTORE is enabled then people have already done far
  2073.      *  cleverer things and we should behave. 
  2074.      */
  2076.     lo |= 15; /* Write combine enables */
  2077.     wrmsr(MSR_IDT_MCR_CTRL, lo, hi);
  2078. }   /*  End Function centaur_mcr1_init  */
  2080. /*
  2081.  * Initialise the original winchip with read only MCR registers
  2082.  * no used bitmask for the BIOS to pass on and write only control
  2083.  */
  2084.  
  2085. static void __init centaur_mcr0_init(void)
  2086. {
  2087.     unsigned i;
  2089.     /* Unfortunately, MCR's are read-only, so there is no way to
  2090.      * find out what the bios might have done.
  2091.      */
  2092.      
  2093.     /* Clear any unconfigured MCR's.
  2094.      * This way we are sure that the centaur_mcr array contains the actual
  2095.      * values. The disadvantage is that any BIOS tweaks are thus undone.
  2096.      *
  2097.      */
  2098.     for (i = 0; i < 8; ++i)
  2099.     {
  2100.      if(centaur_mcr[i]. high == 0 && centaur_mcr[i].low == 0)
  2101. wrmsr (MSR_IDT_MCR0 + i , 0, 0);
  2102.     }
  2104.     wrmsr(MSR_IDT_MCR_CTRL, 0x01F0001F, 0); /* Write only */
  2105. }   /*  End Function centaur_mcr0_init  */
  2107. /*
  2108.  * Initialise Winchip series MCR registers
  2109.  */
  2110.  
  2111. static void __init centaur_mcr_init(void)
  2112. {
  2113.     struct set_mtrr_context ctxt;
  2115.     set_mtrr_prepare_save (&ctxt);
  2116.     set_mtrr_disable (&ctxt);
  2118.     if(boot_cpu_data.x86_model==4)
  2119.      centaur_mcr0_init();
  2120.     else if(boot_cpu_data.x86_model==8 || boot_cpu_data.x86_model == 9)
  2121.      centaur_mcr1_init();
  2123.     set_mtrr_done (&ctxt);
  2124. }   /*  End Function centaur_mcr_init  */
  2126. static int __init mtrr_setup(void)
  2127. {
  2128.     if ( test_bit(X86_FEATURE_MTRR, &boot_cpu_data.x86_capability) ) {
  2129. /* Intel (P6) standard MTRRs */
  2130. mtrr_if = MTRR_IF_INTEL;
  2131. get_mtrr = intel_get_mtrr;
  2132. set_mtrr_up = intel_set_mtrr_up;
  2133. switch (boot_cpu_data.x86_vendor) {
  2135. case X86_VENDOR_AMD:
  2136. /* The original Athlon docs said that
  2137.    total addressable memory is 44 bits wide.
  2138.    It was not really clear whether its MTRRs
  2139.    follow this or not. (Read: 44 or 36 bits).
  2140.    However, "x86-64_overview.pdf" explicitly
  2141.    states that "previous implementations support
  2142.    36 bit MTRRs" and also provides a way to
  2143.    query the width (in bits) of the physical
  2144.    addressable memory on the Hammer family.
  2145.  */
  2146. if (boot_cpu_data.x86 == 7 && (cpuid_eax(0x80000000) >= 0x80000008)) {
  2147. u32 phys_addr;
  2148. phys_addr = cpuid_eax(0x80000008) & 0xff ;
  2149. size_or_mask = ~((1 << (phys_addr - PAGE_SHIFT)) - 1);
  2150. size_and_mask = ~size_or_mask & 0xfff00000;
  2151. break;
  2152. }
  2153. size_or_mask  = 0xff000000; /* 36 bits */
  2154. size_and_mask = 0x00f00000;
  2155. break;
  2157. case X86_VENDOR_CENTAUR:
  2158. /* VIA Cyrix family have Intel style MTRRs, but don't support PAE */
  2159. if (boot_cpu_data.x86 == 6) {
  2160. size_or_mask  = 0xfff00000; /* 32 bits */
  2161. size_and_mask = 0;
  2162. }
  2163. break;
  2165. default:
  2166. /* Intel, etc. */
  2167. size_or_mask  = 0xff000000; /* 36 bits */
  2168. size_and_mask = 0x00f00000;
  2169. break;
  2170. }
  2172.     } else if ( test_bit(X86_FEATURE_K6_MTRR, &boot_cpu_data.x86_capability) ) {
  2173. /* Pre-Athlon (K6) AMD CPU MTRRs */
  2174. mtrr_if = MTRR_IF_AMD_K6;
  2175. get_mtrr = amd_get_mtrr;
  2176. set_mtrr_up = amd_set_mtrr_up;
  2177. size_or_mask  = 0xfff00000; /* 32 bits */
  2178. size_and_mask = 0;
  2179.     } else if ( test_bit(X86_FEATURE_CYRIX_ARR, &boot_cpu_data.x86_capability) ) {
  2180. /* Cyrix ARRs */
  2181. mtrr_if = MTRR_IF_CYRIX_ARR;
  2182. get_mtrr = cyrix_get_arr;
  2183. set_mtrr_up = cyrix_set_arr_up;
  2184. get_free_region = cyrix_get_free_region;
  2185. cyrix_arr_init();
  2186. size_or_mask  = 0xfff00000; /* 32 bits */
  2187. size_and_mask = 0;
  2188.     } else if ( test_bit(X86_FEATURE_CENTAUR_MCR, &boot_cpu_data.x86_capability) ) {
  2189. /* Centaur MCRs */
  2190. mtrr_if = MTRR_IF_CENTAUR_MCR;
  2191. get_mtrr = centaur_get_mcr;
  2192. set_mtrr_up = centaur_set_mcr_up;
  2193. get_free_region = centaur_get_free_region;
  2194. centaur_mcr_init();
  2195. size_or_mask  = 0xfff00000; /* 32 bits */
  2196. size_and_mask = 0;
  2197.     } else {
  2198. /* No supported MTRR interface */
  2199. mtrr_if = MTRR_IF_NONE;
  2200.     }
  2202.     printk ("mtrr: v%s Richard Gooch (rgooch@atnf.csiro.au)n"
  2203.     "mtrr: detected mtrr type: %sn",
  2204.     MTRR_VERSION, mtrr_if_name[mtrr_if]);
  2206.     return (mtrr_if != MTRR_IF_NONE);
  2207. }   /*  End Function mtrr_setup  */
  2209. #ifdef CONFIG_SMP
  2211. static volatile unsigned long smp_changes_mask __initdata = 0;
  2212. static struct mtrr_state smp_mtrr_state __initdata = {0, 0};
  2214. void __init mtrr_init_boot_cpu(void)
  2215. {
  2216.     if ( !mtrr_setup () )
  2217. return;
  2219.     if ( mtrr_if == MTRR_IF_INTEL ) {
  2220. /* Only for Intel MTRRs */
  2221. get_mtrr_state (&smp_mtrr_state);
  2222.     }
  2223. }   /*  End Function mtrr_init_boot_cpu  */
  2225. static void __init intel_mtrr_init_secondary_cpu(void)
  2226. {
  2227.     unsigned long mask, count;
  2228.     struct set_mtrr_context ctxt;
  2230.     /*  Note that this is not ideal, since the cache is only flushed/disabled
  2231. for this CPU while the MTRRs are changed, but changing this requires
  2232. more invasive changes to the way the kernel boots  */
  2233.     set_mtrr_prepare_save (&ctxt);
  2234.     set_mtrr_disable (&ctxt);
  2235.     mask = set_mtrr_state (&smp_mtrr_state, &ctxt);
  2236.     set_mtrr_done (&ctxt);
  2237.     /*  Use the atomic bitops to update the global mask  */
  2238.     for (count = 0; count < sizeof mask * 8; ++count)
  2239.     {
  2240. if (mask & 0x01) set_bit (count, &smp_changes_mask);
  2241. mask >>= 1;
  2242.     }
  2243. }   /*  End Function intel_mtrr_init_secondary_cpu  */
  2245. void __init mtrr_init_secondary_cpu(void)
  2246. {
  2247.     switch ( mtrr_if ) {
  2248.     case MTRR_IF_INTEL:
  2249. /* Intel (P6) standard MTRRs */
  2250. intel_mtrr_init_secondary_cpu();
  2251. break;
  2252.     case MTRR_IF_CYRIX_ARR:
  2253. /* This is _completely theoretical_!
  2254.  * I assume here that one day Cyrix will support Intel APIC.
  2255.  * In reality on non-Intel CPUs we won't even get to this routine.
  2256.  * Hopefully no one will plug two Cyrix processors in a dual P5 board.
  2257.  *  :-)
  2258.  */
  2259. cyrix_arr_init_secondary ();
  2260. break;
  2261.     case MTRR_IF_NONE:
  2262. break;
  2263.     default:
  2264. /* I see no MTRRs I can support in SMP mode... */
  2265. printk ("mtrr: SMP support incomplete for this vendorn");
  2266.     }
  2267. }   /*  End Function mtrr_init_secondary_cpu  */
  2268. #endif  /*  CONFIG_SMP  */
  2270. int __init mtrr_init(void)
  2271. {
  2272. #ifdef CONFIG_SMP
  2273.     /* mtrr_setup() should already have been called from mtrr_init_boot_cpu() */
  2275.     if ( mtrr_if == MTRR_IF_INTEL ) {
  2276. finalize_mtrr_state (&smp_mtrr_state);
  2277. mtrr_state_warn (smp_changes_mask);
  2278.     }
  2279. #else
  2280.     if ( !mtrr_setup() )
  2281. return 0; /* MTRRs not supported? */
  2282. #endif
  2284. #ifdef CONFIG_PROC_FS
  2285.     proc_root_mtrr = create_proc_entry ("mtrr", S_IWUSR | S_IRUGO, &proc_root);
  2286.     if (proc_root_mtrr) {
  2287. proc_root_mtrr->owner = THIS_MODULE;
  2288. proc_root_mtrr->proc_fops = &mtrr_fops;
  2289.     }
  2290. #endif
  2291. #ifdef USERSPACE_INTERFACE
  2292.     devfs_handle = devfs_register (NULL, "cpu/mtrr", DEVFS_FL_DEFAULT, 0, 0,
  2293.    S_IFREG | S_IRUGO | S_IWUSR,
  2294.    &mtrr_fops, NULL);
  2295. #endif
  2296.     init_table ();
  2297.     return 0;
  2298. }   /*  End Function mtrr_init  */
  2300. /*
  2301.  * Local Variables:
  2302.  * mode:c
  2303.  * c-file-style:"k&r"
  2304.  * c-basic-offset:4
  2305.  * End:
  2306.  */