arch/i386/kernel/cpu/mtrr/generic.c

   1 /* This only handles 32bit MTRR on 32bit hosts. This is strictly wrong
   2    because MTRRs can span upto 40 bits (36bits on most modern x86) */
   3 #include <linux/init.h>
   4 #include <linux/slab.h>
   5 #include <linux/mm.h>
   6 #include <asm/io.h>
   7 #include <asm/mtrr.h>
   8 #include <asm/msr.h>
   9 #include <asm/system.h>
  10 #include <asm/cpufeature.h>
  11 #include <asm/tlbflush.h>
  12 #include "mtrr.h"
  13
  14 struct mtrr_state {
  15         struct mtrr_var_range *var_ranges;
  16         mtrr_type fixed_ranges[NUM_FIXED_RANGES];
  17         unsigned char enabled;
  18         mtrr_type def_type;
  19 };
  20
  21 static unsigned long smp_changes_mask;
  22 static struct mtrr_state mtrr_state = {};
  23
  24 /*  Get the MSR pair relating to a var range  */
  25 static void __init
  26 get_mtrr_var_range(unsigned int index, struct mtrr_var_range *vr)
  27 {
  28         rdmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
  29         rdmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
  30 }
  31
  32 static void __init
  33 get_fixed_ranges(mtrr_type * frs)
  34 {
  35         unsigned int *p = (unsigned int *) frs;
  36         int i;
  37
  38         rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]);
  39
  40         for (i = 0; i < 2; i++)
  41                 rdmsr(MTRRfix16K_80000_MSR + i, p[2 + i * 2], p[3 + i * 2]);
  42         for (i = 0; i < 8; i++)
  43                 rdmsr(MTRRfix4K_C0000_MSR + i, p[6 + i * 2], p[7 + i * 2]);
  44 }
  45
  46 /*  Grab all of the MTRR state for this CPU into *state  */
  47 void __init get_mtrr_state(void)
  48 {
  49         unsigned int i;
  50         struct mtrr_var_range *vrs;
  51         unsigned lo, dummy;
  52
  53         if (!mtrr_state.var_ranges) {
  54                 mtrr_state.var_ranges = kmalloc(num_var_ranges * sizeof (struct mtrr_var_range),
  55                                                 GFP_KERNEL);
  56                 if (!mtrr_state.var_ranges)
  57                         return;
  58         }
  59         vrs = mtrr_state.var_ranges;
  60
  61         for (i = 0; i < num_var_ranges; i++)
  62                 get_mtrr_var_range(i, &vrs[i]);
  63         get_fixed_ranges(mtrr_state.fixed_ranges);
  64
  65         rdmsr(MTRRdefType_MSR, lo, dummy);
  66         mtrr_state.def_type = (lo & 0xff);
  67         mtrr_state.enabled = (lo & 0xc00) >> 10;
  68 }
  69
  70 /*  Free resources associated with a struct mtrr_state  */
  71 void __init finalize_mtrr_state(void)
  72 {
  73         kfree(mtrr_state.var_ranges);
  74         mtrr_state.var_ranges = NULL;
  75 }
  76
  77 /*  Some BIOS's are fucked and don't set all MTRRs the same!  */
  78 void __init mtrr_state_warn(void)
  79 {
  80         unsigned long mask = smp_changes_mask;
  81
  82         if (!mask)
  83                 return;
  84         if (mask & MTRR_CHANGE_MASK_FIXED)
  85                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent fixed MTRR settings\n");
  86         if (mask & MTRR_CHANGE_MASK_VARIABLE)
  87                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent variable MTRR settings\n");
  88         if (mask & MTRR_CHANGE_MASK_DEFTYPE)
  89                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent MTRRdefType settings\n");
  90         printk(KERN_INFO "mtrr: probably your BIOS does not setup all CPUs.\n");
  91         printk(KERN_INFO "mtrr: corrected configuration.\n");
  92 }
  93
  94 /* Doesn't attempt to pass an error out to MTRR users
  95    because it's quite complicated in some cases and probably not
  96    worth it because the best error handling is to ignore it. */
  97 void mtrr_wrmsr(unsigned msr, unsigned a, unsigned b)
  98 {
  99         if (wrmsr_safe(msr, a, b) < 0)
 100                 printk(KERN_ERR
 101                         "MTRR: CPU %u: Writing MSR %x to %x:%x failed\n",
 102                         smp_processor_id(), msr, a, b);
 103 }
 104
 105 int generic_get_free_region(unsigned long base, unsigned long size)
 106 /*  [SUMMARY] Get a free MTRR.
 107     <base> The starting (base) address of the region.
 108     <size> The size (in bytes) of the region.
 109     [RETURNS] The index of the region on success, else -1 on error.
 110 */
 111 {
 112         int i, max;
 113         mtrr_type ltype;
 114         unsigned long lbase;
 115         unsigned lsize;
 116
 117         max = num_var_ranges;
 118         for (i = 0; i < max; ++i) {
 119                 mtrr_if->get(i, &lbase, &lsize, &ltype);
 120                 if (lsize == 0)
 121                         return i;
 122         }
 123         return -ENOSPC;
 124 }
 125
 126 static void generic_get_mtrr(unsigned int reg, unsigned long *base,
 127                              unsigned int *size, mtrr_type * type)
 128 {
 129         unsigned int mask_lo, mask_hi, base_lo, base_hi;
 130
 131         rdmsr(MTRRphysMask_MSR(reg), mask_lo, mask_hi);
 132         if ((mask_lo & 0x800) == 0) {
 133                 /*  Invalid (i.e. free) range  */
 134                 *base = 0;
 135                 *size = 0;
 136                 *type = 0;
 137                 return;
 138         }
 139
 140         rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi);
 141
 142         /* Work out the shifted address mask. */
 143         mask_lo = size_or_mask | mask_hi << (32 - PAGE_SHIFT)
 144             | mask_lo >> PAGE_SHIFT;
 145
 146         /* This works correctly if size is a power of two, i.e. a
 147            contiguous range. */
 148         *size = -mask_lo;
 149         *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT;
 150         *type = base_lo & 0xff;
 151 }
 152
 153 static int set_fixed_ranges(mtrr_type * frs)
 154 {
 155         unsigned int *p = (unsigned int *) frs;
 156         int changed = FALSE;
 157         int i;
 158         unsigned int lo, hi;
 159
 160         rdmsr(MTRRfix64K_00000_MSR, lo, hi);
 161         if (p[0] != lo || p[1] != hi) {
 162                 mtrr_wrmsr(MTRRfix64K_00000_MSR, p[0], p[1]);
 163                 changed = TRUE;
 164         }
 165
 166         for (i = 0; i < 2; i++) {
 167                 rdmsr(MTRRfix16K_80000_MSR + i, lo, hi);
 168                 if (p[2 + i * 2] != lo || p[3 + i * 2] != hi) {
 169                         mtrr_wrmsr(MTRRfix16K_80000_MSR + i, p[2 + i * 2],
 170                               p[3 + i * 2]);
 171                         changed = TRUE;
 172                 }
 173         }
 174
 175         for (i = 0; i < 8; i++) {
 176                 rdmsr(MTRRfix4K_C0000_MSR + i, lo, hi);
 177                 if (p[6 + i * 2] != lo || p[7 + i * 2] != hi) {
 178                         mtrr_wrmsr(MTRRfix4K_C0000_MSR + i, p[6 + i * 2],
 179                               p[7 + i * 2]);
 180                         changed = TRUE;
 181                 }
 182         }
 183         return changed;
 184 }
 185
 186 /*  Set the MSR pair relating to a var range. Returns TRUE if
 187     changes are made  */
 188 static int set_mtrr_var_ranges(unsigned int index, struct mtrr_var_range *vr)
 189 {
 190         unsigned int lo, hi;
 191         int changed = FALSE;
 192
 193         rdmsr(MTRRphysBase_MSR(index), lo, hi);
 194         if ((vr->base_lo & 0xfffff0ffUL) != (lo & 0xfffff0ffUL)
 195             || (vr->base_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
 196                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
 197                 mtrr_wrmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
 198                 changed = TRUE;
 199         }
 200
 201         rdmsr(MTRRphysMask_MSR(index), lo, hi);
 202
 203         if ((vr->mask_lo & 0xfffff800UL) != (lo & 0xfffff800UL)
 204             || (vr->mask_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
 205                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
 206                 mtrr_wrmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
 207                 changed = TRUE;
 208         }
 209         return changed;
 210 }
 211
 212 static unsigned long set_mtrr_state(u32 deftype_lo, u32 deftype_hi)
 213 /*  [SUMMARY] Set the MTRR state for this CPU.
 214     <state> The MTRR state information to read.
 215     <ctxt> Some relevant CPU context.
 216     [NOTE] The CPU must already be in a safe state for MTRR changes.
 217     [RETURNS] 0 if no changes made, else a mask indication what was changed.
 218 */
 219 {
 220         unsigned int i;
 221         unsigned long change_mask = 0;
 222
 223         for (i = 0; i < num_var_ranges; i++)
 224                 if (set_mtrr_var_ranges(i, &mtrr_state.var_ranges[i]))
 225                         change_mask |= MTRR_CHANGE_MASK_VARIABLE;
 226
 227         if (set_fixed_ranges(mtrr_state.fixed_ranges))
 228                 change_mask |= MTRR_CHANGE_MASK_FIXED;
 229
 230         /*  Set_mtrr_restore restores the old value of MTRRdefType,
 231            so to set it we fiddle with the saved value  */
 232         if ((deftype_lo & 0xff) != mtrr_state.def_type
 233             || ((deftype_lo & 0xc00) >> 10) != mtrr_state.enabled) {
 234                 deftype_lo |= (mtrr_state.def_type | mtrr_state.enabled << 10);
 235                 change_mask |= MTRR_CHANGE_MASK_DEFTYPE;
 236         }
 237
 238         return change_mask;
 239 }
 240
 241
 242 static unsigned long cr4 = 0;
 243 static u32 deftype_lo, deftype_hi;
 244 static DEFINE_SPINLOCK(set_atomicity_lock);
 245
 246 /*
 247  * Since we are disabling the cache don't allow any interrupts - they
 248  * would run extremely slow and would only increase the pain.  The caller must
 249  * ensure that local interrupts are disabled and are reenabled after post_set()
 250  * has been called.
 251  */
 252
 253 static void prepare_set(void)
 254 {
 255         unsigned long cr0;
 256
 257         /*  Note that this is not ideal, since the cache is only flushed/disabled
 258            for this CPU while the MTRRs are changed, but changing this requires
 259            more invasive changes to the way the kernel boots  */
 260
 261         spin_lock(&set_atomicity_lock);
 262
 263         /*  Enter the no-fill (CD=1, NW=0) cache mode and flush caches. */
 264         cr0 = read_cr0() | 0x40000000;  /* set CD flag */
 265         write_cr0(cr0);
 266         wbinvd();
 267
 268         /*  Save value of CR4 and clear Page Global Enable (bit 7)  */
 269         if ( cpu_has_pge ) {
 270                 cr4 = read_cr4();
 271                 write_cr4(cr4 & ~X86_CR4_PGE);
 272         }
 273
 274         /* Flush all TLBs via a mov %cr3, %reg; mov %reg, %cr3 */
 275         __flush_tlb();
 276
 277         /*  Save MTRR state */
 278         rdmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
 279
 280         /*  Disable MTRRs, and set the default type to uncached  */
 281         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo & 0xf300UL, deftype_hi);
 282 }
 283
 284 static void post_set(void)
 285 {
 286         /*  Flush TLBs (no need to flush caches - they are disabled)  */
 287         __flush_tlb();
 288
 289         /* Intel (P6) standard MTRRs */
 290         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
 291
 292         /*  Enable caches  */
 293         write_cr0(read_cr0() & 0xbfffffff);
 294
 295         /*  Restore value of CR4  */
 296         if ( cpu_has_pge )
 297                 write_cr4(cr4);
 298         spin_unlock(&set_atomicity_lock);
 299 }
 300
 301 static void generic_set_all(void)
 302 {
 303         unsigned long mask, count;
 304         unsigned long flags;
 305
 306         local_irq_save(flags);
 307         prepare_set();
 308
 309         /* Actually set the state */
 310         mask = set_mtrr_state(deftype_lo,deftype_hi);
 311
 312         post_set();
 313         local_irq_restore(flags);
 314
 315         /*  Use the atomic bitops to update the global mask  */
 316         for (count = 0; count < sizeof mask * 8; ++count) {
 317                 if (mask & 0x01)
 318                         set_bit(count, &smp_changes_mask);
 319                 mask >>= 1;
 320         }
 321
 322 }
 323
 324 static void generic_set_mtrr(unsigned int reg, unsigned long base,
 325                              unsigned long size, mtrr_type type)
 326 /*  [SUMMARY] Set variable MTRR register on the local CPU.
 327     <reg> The register to set.
 328     <base> The base address of the region.
 329     <size> The size of the region. If this is 0 the region is disabled.
 330     <type> The type of the region.
 331     <do_safe> If TRUE, do the change safely. If FALSE, safety measures should
 332     be done externally.
 333     [RETURNS] Nothing.
 334 */
 335 {
 336         unsigned long flags;
 337
 338         local_irq_save(flags);
 339         prepare_set();
 340
 341         if (size == 0) {
 342                 /* The invalid bit is kept in the mask, so we simply clear the
 343                    relevant mask register to disable a range. */
 344                 mtrr_wrmsr(MTRRphysMask_MSR(reg), 0, 0);
 345         } else {
 346                 mtrr_wrmsr(MTRRphysBase_MSR(reg), base << PAGE_SHIFT | type,
 347                       (base & size_and_mask) >> (32 - PAGE_SHIFT));
 348                 mtrr_wrmsr(MTRRphysMask_MSR(reg), -size << PAGE_SHIFT | 0x800,
 349                       (-size & size_and_mask) >> (32 - PAGE_SHIFT));
 350         }
 351
 352         post_set();
 353         local_irq_restore(flags);
 354 }
 355
 356 int generic_validate_add_page(unsigned long base, unsigned long size, unsigned int type)
 357 {
 358         unsigned long lbase, last;
 359
 360         /*  For Intel PPro stepping <= 7, must be 4 MiB aligned
 361             and not touch 0x70000000->0x7003FFFF */
 362         if (is_cpu(INTEL) && boot_cpu_data.x86 == 6 &&
 363             boot_cpu_data.x86_model == 1 &&
 364             boot_cpu_data.x86_mask <= 7) {
 365                 if (base & ((1 << (22 - PAGE_SHIFT)) - 1)) {
 366                         printk(KERN_WARNING "mtrr: base(0x%lx000) is not 4 MiB aligned\n", base);
 367                         return -EINVAL;
 368                 }
 369                 if (!(base + size < 0x70000000 || base > 0x7003FFFF) &&
 370                     (type == MTRR_TYPE_WRCOMB
 371                      || type == MTRR_TYPE_WRBACK)) {
 372                         printk(KERN_WARNING "mtrr: writable mtrr between 0x70000000 and 0x7003FFFF may hang the CPU.\n");
 373                         return -EINVAL;
 374                 }
 375         }
 376
 377         if (base + size < 0x100) {
 378                 printk(KERN_WARNING "mtrr: cannot set region below 1 MiB (0x%lx000,0x%lx000)\n",
 379                        base, size);
 380                 return -EINVAL;
 381         }
 382         /*  Check upper bits of base and last are equal and lower bits are 0
 383             for base and 1 for last  */
 384         last = base + size - 1;
 385         for (lbase = base; !(lbase & 1) && (last & 1);
 386              lbase = lbase >> 1, last = last >> 1) ;
 387         if (lbase != last) {
 388                 printk(KERN_WARNING "mtrr: base(0x%lx000) is not aligned on a size(0x%lx000) boundary\n",
 389                        base, size);
 390                 return -EINVAL;
 391         }
 392         return 0;
 393 }
 394
 395
 396 static int generic_have_wrcomb(void)
 397 {
 398         unsigned long config, dummy;
 399         rdmsr(MTRRcap_MSR, config, dummy);
 400         return (config & (1 << 10));
 401 }
 402
 403 int positive_have_wrcomb(void)
 404 {
 405         return 1;
 406 }
 407
 408 /* generic structure...
 409  */
 410 struct mtrr_ops generic_mtrr_ops = {
 411         .use_intel_if      = 1,
 412         .set_all           = generic_set_all,
 413         .get               = generic_get_mtrr,
 414         .get_free_region   = generic_get_free_region,
 415         .set               = generic_set_mtrr,
 416         .validate_add_page = generic_validate_add_page,
 417         .have_wrcomb       = generic_have_wrcomb,
 418 };