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 <linux/module.h>
   7 #include <asm/io.h>
   8 #include <asm/mtrr.h>
   9 #include <asm/msr.h>
  10 #include <asm/system.h>
  11 #include <asm/cpufeature.h>
  12 #include <asm/tlbflush.h>
  13 #include "mtrr.h"
  14
  15 struct mtrr_state {
  16         struct mtrr_var_range *var_ranges;
  17         mtrr_type fixed_ranges[NUM_FIXED_RANGES];
  18         unsigned char enabled;
  19         unsigned char have_fixed;
  20         mtrr_type def_type;
  21 };
  22
  23 struct fixed_range_block {
  24         int base_msr; /* start address of an MTRR block */
  25         int ranges;   /* number of MTRRs in this block  */
  26 };
  27
  28 static struct fixed_range_block fixed_range_blocks[] = {
  29         { MTRRfix64K_00000_MSR, 1 }, /* one  64k MTRR  */
  30         { MTRRfix16K_80000_MSR, 2 }, /* two  16k MTRRs */
  31         { MTRRfix4K_C0000_MSR,  8 }, /* eight 4k MTRRs */
  32         {}
  33 };
  34
  35 static unsigned long smp_changes_mask;
  36 static struct mtrr_state mtrr_state = {};
  37
  38 #undef MODULE_PARAM_PREFIX
  39 #define MODULE_PARAM_PREFIX "mtrr."
  40
  41 static int mtrr_show;
  42 module_param_named(show, mtrr_show, bool, 0);
  43
  44 /*  Get the MSR pair relating to a var range  */
  45 static void
  46 get_mtrr_var_range(unsigned int index, struct mtrr_var_range *vr)
  47 {
  48         rdmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
  49         rdmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
  50 }
  51
  52 static void
  53 get_fixed_ranges(mtrr_type * frs)
  54 {
  55         unsigned int *p = (unsigned int *) frs;
  56         int i;
  57
  58         rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]);
  59
  60         for (i = 0; i < 2; i++)
  61                 rdmsr(MTRRfix16K_80000_MSR + i, p[2 + i * 2], p[3 + i * 2]);
  62         for (i = 0; i < 8; i++)
  63                 rdmsr(MTRRfix4K_C0000_MSR + i, p[6 + i * 2], p[7 + i * 2]);
  64 }
  65
  66 void mtrr_save_fixed_ranges(void *info)
  67 {
  68         if (cpu_has_mtrr)
  69                 get_fixed_ranges(mtrr_state.fixed_ranges);
  70 }
  71
  72 static void print_fixed(unsigned base, unsigned step, const mtrr_type*types)
  73 {
  74         unsigned i;
  75
  76         for (i = 0; i < 8; ++i, ++types, base += step)
  77                 printk(KERN_INFO "MTRR %05X-%05X %s\n",
  78                         base, base + step - 1, mtrr_attrib_to_str(*types));
  79 }
  80
  81 /*  Grab all of the MTRR state for this CPU into *state  */
  82 void get_mtrr_state(void)
  83 {
  84         unsigned int i;
  85         struct mtrr_var_range *vrs;
  86         unsigned lo, dummy;
  87
  88         if (!mtrr_state.var_ranges) {
  89                 mtrr_state.var_ranges = kmalloc(num_var_ranges * sizeof (struct mtrr_var_range),
  90                                                 GFP_KERNEL);
  91                 if (!mtrr_state.var_ranges)
  92                         return;
  93         }
  94         vrs = mtrr_state.var_ranges;
  95
  96         rdmsr(MTRRcap_MSR, lo, dummy);
  97         mtrr_state.have_fixed = (lo >> 8) & 1;
  98
  99         for (i = 0; i < num_var_ranges; i++)
 100                 get_mtrr_var_range(i, &vrs[i]);
 101         if (mtrr_state.have_fixed)
 102                 get_fixed_ranges(mtrr_state.fixed_ranges);
 103
 104         rdmsr(MTRRdefType_MSR, lo, dummy);
 105         mtrr_state.def_type = (lo & 0xff);
 106         mtrr_state.enabled = (lo & 0xc00) >> 10;
 107
 108         if (mtrr_show) {
 109                 int high_width;
 110
 111                 printk(KERN_INFO "MTRR default type: %s\n", mtrr_attrib_to_str(mtrr_state.def_type));
 112                 if (mtrr_state.have_fixed) {
 113                         printk(KERN_INFO "MTRR fixed ranges %sabled:\n",
 114                                mtrr_state.enabled & 1 ? "en" : "dis");
 115                         print_fixed(0x00000, 0x10000, mtrr_state.fixed_ranges + 0);
 116                         for (i = 0; i < 2; ++i)
 117                                 print_fixed(0x80000 + i * 0x20000, 0x04000, mtrr_state.fixed_ranges + (i + 1) * 8);
 118                         for (i = 0; i < 8; ++i)
 119                                 print_fixed(0xC0000 + i * 0x08000, 0x01000, mtrr_state.fixed_ranges + (i + 3) * 8);
 120                 }
 121                 printk(KERN_INFO "MTRR variable ranges %sabled:\n",
 122                        mtrr_state.enabled & 2 ? "en" : "dis");
 123                 high_width = ((size_or_mask ? ffs(size_or_mask) - 1 : 32) - (32 - PAGE_SHIFT) + 3) / 4;
 124                 for (i = 0; i < num_var_ranges; ++i) {
 125                         if (mtrr_state.var_ranges[i].mask_lo & (1 << 11))
 126                                 printk(KERN_INFO "MTRR %u base %0*X%05X000 mask %0*X%05X000 %s\n",
 127                                        i,
 128                                        high_width,
 129                                        mtrr_state.var_ranges[i].base_hi,
 130                                        mtrr_state.var_ranges[i].base_lo >> 12,
 131                                        high_width,
 132                                        mtrr_state.var_ranges[i].mask_hi,
 133                                        mtrr_state.var_ranges[i].mask_lo >> 12,
 134                                        mtrr_attrib_to_str(mtrr_state.var_ranges[i].base_lo & 0xff));
 135                         else
 136                                 printk(KERN_INFO "MTRR %u disabled\n", i);
 137                 }
 138         }
 139 }
 140
 141 /*  Some BIOS's are fucked and don't set all MTRRs the same!  */
 142 void __init mtrr_state_warn(void)
 143 {
 144         unsigned long mask = smp_changes_mask;
 145
 146         if (!mask)
 147                 return;
 148         if (mask & MTRR_CHANGE_MASK_FIXED)
 149                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent fixed MTRR settings\n");
 150         if (mask & MTRR_CHANGE_MASK_VARIABLE)
 151                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent variable MTRR settings\n");
 152         if (mask & MTRR_CHANGE_MASK_DEFTYPE)
 153                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent MTRRdefType settings\n");
 154         printk(KERN_INFO "mtrr: probably your BIOS does not setup all CPUs.\n");
 155         printk(KERN_INFO "mtrr: corrected configuration.\n");
 156 }
 157
 158 /* Doesn't attempt to pass an error out to MTRR users
 159    because it's quite complicated in some cases and probably not
 160    worth it because the best error handling is to ignore it. */
 161 void mtrr_wrmsr(unsigned msr, unsigned a, unsigned b)
 162 {
 163         if (wrmsr_safe(msr, a, b) < 0)
 164                 printk(KERN_ERR
 165                         "MTRR: CPU %u: Writing MSR %x to %x:%x failed\n",
 166                         smp_processor_id(), msr, a, b);
 167 }
 168
 169 /**
 170  * Enable and allow read/write of extended fixed-range MTRR bits on K8 CPUs
 171  * see AMD publication no. 24593, chapter 3.2.1 for more information
 172  */
 173 static inline void k8_enable_fixed_iorrs(void)
 174 {
 175         unsigned lo, hi;
 176
 177         rdmsr(MSR_K8_SYSCFG, lo, hi);
 178         mtrr_wrmsr(MSR_K8_SYSCFG, lo
 179                                 | K8_MTRRFIXRANGE_DRAM_ENABLE
 180                                 | K8_MTRRFIXRANGE_DRAM_MODIFY, hi);
 181 }
 182
 183 /**
 184  * Checks and updates an fixed-range MTRR if it differs from the value it
 185  * should have. If K8 extenstions are wanted, update the K8 SYSCFG MSR also.
 186  * see AMD publication no. 24593, chapter 7.8.1, page 233 for more information
 187  * \param msr MSR address of the MTTR which should be checked and updated
 188  * \param changed pointer which indicates whether the MTRR needed to be changed
 189  * \param msrwords pointer to the MSR values which the MSR should have
 190  */
 191 static void set_fixed_range(int msr, int * changed, unsigned int * msrwords)
 192 {
 193         unsigned lo, hi;
 194
 195         rdmsr(msr, lo, hi);
 196
 197         if (lo != msrwords[0] || hi != msrwords[1]) {
 198                 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
 199                     boot_cpu_data.x86 == 15 &&
 200                     ((msrwords[0] | msrwords[1]) & K8_MTRR_RDMEM_WRMEM_MASK))
 201                         k8_enable_fixed_iorrs();
 202                 mtrr_wrmsr(msr, msrwords[0], msrwords[1]);
 203                 *changed = TRUE;
 204         }
 205 }
 206
 207 int generic_get_free_region(unsigned long base, unsigned long size, int replace_reg)
 208 /*  [SUMMARY] Get a free MTRR.
 209     <base> The starting (base) address of the region.
 210     <size> The size (in bytes) of the region.
 211     [RETURNS] The index of the region on success, else -1 on error.
 212 */
 213 {
 214         int i, max;
 215         mtrr_type ltype;
 216         unsigned long lbase, lsize;
 217
 218         max = num_var_ranges;
 219         if (replace_reg >= 0 && replace_reg < max)
 220                 return replace_reg;
 221         for (i = 0; i < max; ++i) {
 222                 mtrr_if->get(i, &lbase, &lsize, &ltype);
 223                 if (lsize == 0)
 224                         return i;
 225         }
 226         return -ENOSPC;
 227 }
 228
 229 static void generic_get_mtrr(unsigned int reg, unsigned long *base,
 230                              unsigned long *size, mtrr_type *type)
 231 {
 232         unsigned int mask_lo, mask_hi, base_lo, base_hi;
 233
 234         rdmsr(MTRRphysMask_MSR(reg), mask_lo, mask_hi);
 235         if ((mask_lo & 0x800) == 0) {
 236                 /*  Invalid (i.e. free) range  */
 237                 *base = 0;
 238                 *size = 0;
 239                 *type = 0;
 240                 return;
 241         }
 242
 243         rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi);
 244
 245         /* Work out the shifted address mask. */
 246         mask_lo = size_or_mask | mask_hi << (32 - PAGE_SHIFT)
 247             | mask_lo >> PAGE_SHIFT;
 248
 249         /* This works correctly if size is a power of two, i.e. a
 250            contiguous range. */
 251         *size = -mask_lo;
 252         *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT;
 253         *type = base_lo & 0xff;
 254 }
 255
 256 /**
 257  * Checks and updates the fixed-range MTRRs if they differ from the saved set
 258  * \param frs pointer to fixed-range MTRR values, saved by get_fixed_ranges()
 259  */
 260 static int set_fixed_ranges(mtrr_type * frs)
 261 {
 262         unsigned long long *saved = (unsigned long long *) frs;
 263         int changed = FALSE;
 264         int block=-1, range;
 265
 266         while (fixed_range_blocks[++block].ranges)
 267             for (range=0; range < fixed_range_blocks[block].ranges; range++)
 268                 set_fixed_range(fixed_range_blocks[block].base_msr + range,
 269                     &changed, (unsigned int *) saved++);
 270
 271         return changed;
 272 }
 273
 274 /*  Set the MSR pair relating to a var range. Returns TRUE if
 275     changes are made  */
 276 static int set_mtrr_var_ranges(unsigned int index, struct mtrr_var_range *vr)
 277 {
 278         unsigned int lo, hi;
 279         int changed = FALSE;
 280
 281         rdmsr(MTRRphysBase_MSR(index), lo, hi);
 282         if ((vr->base_lo & 0xfffff0ffUL) != (lo & 0xfffff0ffUL)
 283             || (vr->base_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
 284                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
 285                 mtrr_wrmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
 286                 changed = TRUE;
 287         }
 288
 289         rdmsr(MTRRphysMask_MSR(index), lo, hi);
 290
 291         if ((vr->mask_lo & 0xfffff800UL) != (lo & 0xfffff800UL)
 292             || (vr->mask_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
 293                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
 294                 mtrr_wrmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
 295                 changed = TRUE;
 296         }
 297         return changed;
 298 }
 299
 300 static u32 deftype_lo, deftype_hi;
 301
 302 static unsigned long set_mtrr_state(void)
 303 /*  [SUMMARY] Set the MTRR state for this CPU.
 304     <state> The MTRR state information to read.
 305     <ctxt> Some relevant CPU context.
 306     [NOTE] The CPU must already be in a safe state for MTRR changes.
 307     [RETURNS] 0 if no changes made, else a mask indication what was changed.
 308 */
 309 {
 310         unsigned int i;
 311         unsigned long change_mask = 0;
 312
 313         for (i = 0; i < num_var_ranges; i++)
 314                 if (set_mtrr_var_ranges(i, &mtrr_state.var_ranges[i]))
 315                         change_mask |= MTRR_CHANGE_MASK_VARIABLE;
 316
 317         if (mtrr_state.have_fixed && set_fixed_ranges(mtrr_state.fixed_ranges))
 318                 change_mask |= MTRR_CHANGE_MASK_FIXED;
 319
 320         /*  Set_mtrr_restore restores the old value of MTRRdefType,
 321            so to set it we fiddle with the saved value  */
 322         if ((deftype_lo & 0xff) != mtrr_state.def_type
 323             || ((deftype_lo & 0xc00) >> 10) != mtrr_state.enabled) {
 324                 deftype_lo = (deftype_lo & ~0xcff) | mtrr_state.def_type | (mtrr_state.enabled << 10);
 325                 change_mask |= MTRR_CHANGE_MASK_DEFTYPE;
 326         }
 327
 328         return change_mask;
 329 }
 330
 331
 332 static unsigned long cr4 = 0;
 333 static DEFINE_SPINLOCK(set_atomicity_lock);
 334
 335 /*
 336  * Since we are disabling the cache don't allow any interrupts - they
 337  * would run extremely slow and would only increase the pain.  The caller must
 338  * ensure that local interrupts are disabled and are reenabled after post_set()
 339  * has been called.
 340  */
 341
 342 static void prepare_set(void) __acquires(set_atomicity_lock)
 343 {
 344         unsigned long cr0;
 345
 346         /*  Note that this is not ideal, since the cache is only flushed/disabled
 347            for this CPU while the MTRRs are changed, but changing this requires
 348            more invasive changes to the way the kernel boots  */
 349
 350         spin_lock(&set_atomicity_lock);
 351
 352         /*  Enter the no-fill (CD=1, NW=0) cache mode and flush caches. */
 353         cr0 = read_cr0() | 0x40000000;  /* set CD flag */
 354         write_cr0(cr0);
 355         wbinvd();
 356
 357         /*  Save value of CR4 and clear Page Global Enable (bit 7)  */
 358         if ( cpu_has_pge ) {
 359                 cr4 = read_cr4();
 360                 write_cr4(cr4 & ~X86_CR4_PGE);
 361         }
 362
 363         /* Flush all TLBs via a mov %cr3, %reg; mov %reg, %cr3 */
 364         __flush_tlb();
 365
 366         /*  Save MTRR state */
 367         rdmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
 368
 369         /*  Disable MTRRs, and set the default type to uncached  */
 370         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo & ~0xcff, deftype_hi);
 371 }
 372
 373 static void post_set(void) __releases(set_atomicity_lock)
 374 {
 375         /*  Flush TLBs (no need to flush caches - they are disabled)  */
 376         __flush_tlb();
 377
 378         /* Intel (P6) standard MTRRs */
 379         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
 380
 381         /*  Enable caches  */
 382         write_cr0(read_cr0() & 0xbfffffff);
 383
 384         /*  Restore value of CR4  */
 385         if ( cpu_has_pge )
 386                 write_cr4(cr4);
 387         spin_unlock(&set_atomicity_lock);
 388 }
 389
 390 static void generic_set_all(void)
 391 {
 392         unsigned long mask, count;
 393         unsigned long flags;
 394
 395         local_irq_save(flags);
 396         prepare_set();
 397
 398         /* Actually set the state */
 399         mask = set_mtrr_state();
 400
 401         post_set();
 402         local_irq_restore(flags);
 403
 404         /*  Use the atomic bitops to update the global mask  */
 405         for (count = 0; count < sizeof mask * 8; ++count) {
 406                 if (mask & 0x01)
 407                         set_bit(count, &smp_changes_mask);
 408                 mask >>= 1;
 409         }
 410
 411 }
 412
 413 static void generic_set_mtrr(unsigned int reg, unsigned long base,
 414                              unsigned long size, mtrr_type type)
 415 /*  [SUMMARY] Set variable MTRR register on the local CPU.
 416     <reg> The register to set.
 417     <base> The base address of the region.
 418     <size> The size of the region. If this is 0 the region is disabled.
 419     <type> The type of the region.
 420     <do_safe> If TRUE, do the change safely. If FALSE, safety measures should
 421     be done externally.
 422     [RETURNS] Nothing.
 423 */
 424 {
 425         unsigned long flags;
 426         struct mtrr_var_range *vr;
 427
 428         vr = &mtrr_state.var_ranges[reg];
 429
 430         local_irq_save(flags);
 431         prepare_set();
 432
 433         if (size == 0) {
 434                 /* The invalid bit is kept in the mask, so we simply clear the
 435                    relevant mask register to disable a range. */
 436                 mtrr_wrmsr(MTRRphysMask_MSR(reg), 0, 0);
 437                 memset(vr, 0, sizeof(struct mtrr_var_range));
 438         } else {
 439                 vr->base_lo = base << PAGE_SHIFT | type;
 440                 vr->base_hi = (base & size_and_mask) >> (32 - PAGE_SHIFT);
 441                 vr->mask_lo = -size << PAGE_SHIFT | 0x800;
 442                 vr->mask_hi = (-size & size_and_mask) >> (32 - PAGE_SHIFT);
 443
 444                 mtrr_wrmsr(MTRRphysBase_MSR(reg), vr->base_lo, vr->base_hi);
 445                 mtrr_wrmsr(MTRRphysMask_MSR(reg), vr->mask_lo, vr->mask_hi);
 446         }
 447
 448         post_set();
 449         local_irq_restore(flags);
 450 }
 451
 452 int generic_validate_add_page(unsigned long base, unsigned long size, unsigned int type)
 453 {
 454         unsigned long lbase, last;
 455
 456         /*  For Intel PPro stepping <= 7, must be 4 MiB aligned
 457             and not touch 0x70000000->0x7003FFFF */
 458         if (is_cpu(INTEL) && boot_cpu_data.x86 == 6 &&
 459             boot_cpu_data.x86_model == 1 &&
 460             boot_cpu_data.x86_mask <= 7) {
 461                 if (base & ((1 << (22 - PAGE_SHIFT)) - 1)) {
 462                         printk(KERN_WARNING "mtrr: base(0x%lx000) is not 4 MiB aligned\n", base);
 463                         return -EINVAL;
 464                 }
 465                 if (!(base + size < 0x70000 || base > 0x7003F) &&
 466                     (type == MTRR_TYPE_WRCOMB
 467                      || type == MTRR_TYPE_WRBACK)) {
 468                         printk(KERN_WARNING "mtrr: writable mtrr between 0x70000000 and 0x7003FFFF may hang the CPU.\n");
 469                         return -EINVAL;
 470                 }
 471         }
 472
 473         /*  Check upper bits of base and last are equal and lower bits are 0
 474             for base and 1 for last  */
 475         last = base + size - 1;
 476         for (lbase = base; !(lbase & 1) && (last & 1);
 477              lbase = lbase >> 1, last = last >> 1) ;
 478         if (lbase != last) {
 479                 printk(KERN_WARNING "mtrr: base(0x%lx000) is not aligned on a size(0x%lx000) boundary\n",
 480                        base, size);
 481                 return -EINVAL;
 482         }
 483         return 0;
 484 }
 485
 486
 487 static int generic_have_wrcomb(void)
 488 {
 489         unsigned long config, dummy;
 490         rdmsr(MTRRcap_MSR, config, dummy);
 491         return (config & (1 << 10));
 492 }
 493
 494 int positive_have_wrcomb(void)
 495 {
 496         return 1;
 497 }
 498
 499 /* generic structure...
 500  */
 501 struct mtrr_ops generic_mtrr_ops = {
 502         .use_intel_if      = 1,
 503         .set_all           = generic_set_all,
 504         .get               = generic_get_mtrr,
 505         .get_free_region   = generic_get_free_region,
 506         .set               = generic_set_mtrr,
 507         .validate_add_page = generic_validate_add_page,
 508         .have_wrcomb       = generic_have_wrcomb,
 509 };