Merge branch 'master' into next
[linux-2.6] / arch / x86 / 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/processor-flags.h>
13 #include <asm/tlbflush.h>
14 #include <asm/pat.h>
15 #include "mtrr.h"
16
17 struct fixed_range_block {
18         int base_msr; /* start address of an MTRR block */
19         int ranges;   /* number of MTRRs in this block  */
20 };
21
22 static struct fixed_range_block fixed_range_blocks[] = {
23         { MTRRfix64K_00000_MSR, 1 }, /* one  64k MTRR  */
24         { MTRRfix16K_80000_MSR, 2 }, /* two  16k MTRRs */
25         { MTRRfix4K_C0000_MSR,  8 }, /* eight 4k MTRRs */
26         {}
27 };
28
29 static unsigned long smp_changes_mask;
30 static int mtrr_state_set;
31 u64 mtrr_tom2;
32
33 struct mtrr_state_type mtrr_state = {};
34 EXPORT_SYMBOL_GPL(mtrr_state);
35
36 static int __initdata mtrr_show;
37 static int __init mtrr_debug(char *opt)
38 {
39         mtrr_show = 1;
40         return 0;
41 }
42 early_param("mtrr.show", mtrr_debug);
43
44 /*
45  * Returns the effective MTRR type for the region
46  * Error returns:
47  * - 0xFE - when the range is "not entirely covered" by _any_ var range MTRR
48  * - 0xFF - when MTRR is not enabled
49  */
50 u8 mtrr_type_lookup(u64 start, u64 end)
51 {
52         int i;
53         u64 base, mask;
54         u8 prev_match, curr_match;
55
56         if (!mtrr_state_set)
57                 return 0xFF;
58
59         if (!mtrr_state.enabled)
60                 return 0xFF;
61
62         /* Make end inclusive end, instead of exclusive */
63         end--;
64
65         /* Look in fixed ranges. Just return the type as per start */
66         if (mtrr_state.have_fixed && (start < 0x100000)) {
67                 int idx;
68
69                 if (start < 0x80000) {
70                         idx = 0;
71                         idx += (start >> 16);
72                         return mtrr_state.fixed_ranges[idx];
73                 } else if (start < 0xC0000) {
74                         idx = 1 * 8;
75                         idx += ((start - 0x80000) >> 14);
76                         return mtrr_state.fixed_ranges[idx];
77                 } else if (start < 0x1000000) {
78                         idx = 3 * 8;
79                         idx += ((start - 0xC0000) >> 12);
80                         return mtrr_state.fixed_ranges[idx];
81                 }
82         }
83
84         /*
85          * Look in variable ranges
86          * Look of multiple ranges matching this address and pick type
87          * as per MTRR precedence
88          */
89         if (!(mtrr_state.enabled & 2)) {
90                 return mtrr_state.def_type;
91         }
92
93         prev_match = 0xFF;
94         for (i = 0; i < num_var_ranges; ++i) {
95                 unsigned short start_state, end_state;
96
97                 if (!(mtrr_state.var_ranges[i].mask_lo & (1 << 11)))
98                         continue;
99
100                 base = (((u64)mtrr_state.var_ranges[i].base_hi) << 32) +
101                        (mtrr_state.var_ranges[i].base_lo & PAGE_MASK);
102                 mask = (((u64)mtrr_state.var_ranges[i].mask_hi) << 32) +
103                        (mtrr_state.var_ranges[i].mask_lo & PAGE_MASK);
104
105                 start_state = ((start & mask) == (base & mask));
106                 end_state = ((end & mask) == (base & mask));
107                 if (start_state != end_state)
108                         return 0xFE;
109
110                 if ((start & mask) != (base & mask)) {
111                         continue;
112                 }
113
114                 curr_match = mtrr_state.var_ranges[i].base_lo & 0xff;
115                 if (prev_match == 0xFF) {
116                         prev_match = curr_match;
117                         continue;
118                 }
119
120                 if (prev_match == MTRR_TYPE_UNCACHABLE ||
121                     curr_match == MTRR_TYPE_UNCACHABLE) {
122                         return MTRR_TYPE_UNCACHABLE;
123                 }
124
125                 if ((prev_match == MTRR_TYPE_WRBACK &&
126                      curr_match == MTRR_TYPE_WRTHROUGH) ||
127                     (prev_match == MTRR_TYPE_WRTHROUGH &&
128                      curr_match == MTRR_TYPE_WRBACK)) {
129                         prev_match = MTRR_TYPE_WRTHROUGH;
130                         curr_match = MTRR_TYPE_WRTHROUGH;
131                 }
132
133                 if (prev_match != curr_match) {
134                         return MTRR_TYPE_UNCACHABLE;
135                 }
136         }
137
138         if (mtrr_tom2) {
139                 if (start >= (1ULL<<32) && (end < mtrr_tom2))
140                         return MTRR_TYPE_WRBACK;
141         }
142
143         if (prev_match != 0xFF)
144                 return prev_match;
145
146         return mtrr_state.def_type;
147 }
148
149 /*  Get the MSR pair relating to a var range  */
150 static void
151 get_mtrr_var_range(unsigned int index, struct mtrr_var_range *vr)
152 {
153         rdmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
154         rdmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
155 }
156
157 /*  fill the MSR pair relating to a var range  */
158 void fill_mtrr_var_range(unsigned int index,
159                 u32 base_lo, u32 base_hi, u32 mask_lo, u32 mask_hi)
160 {
161         struct mtrr_var_range *vr;
162
163         vr = mtrr_state.var_ranges;
164
165         vr[index].base_lo = base_lo;
166         vr[index].base_hi = base_hi;
167         vr[index].mask_lo = mask_lo;
168         vr[index].mask_hi = mask_hi;
169 }
170
171 static void
172 get_fixed_ranges(mtrr_type * frs)
173 {
174         unsigned int *p = (unsigned int *) frs;
175         int i;
176
177         rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]);
178
179         for (i = 0; i < 2; i++)
180                 rdmsr(MTRRfix16K_80000_MSR + i, p[2 + i * 2], p[3 + i * 2]);
181         for (i = 0; i < 8; i++)
182                 rdmsr(MTRRfix4K_C0000_MSR + i, p[6 + i * 2], p[7 + i * 2]);
183 }
184
185 void mtrr_save_fixed_ranges(void *info)
186 {
187         if (cpu_has_mtrr)
188                 get_fixed_ranges(mtrr_state.fixed_ranges);
189 }
190
191 static void print_fixed(unsigned base, unsigned step, const mtrr_type*types)
192 {
193         unsigned i;
194
195         for (i = 0; i < 8; ++i, ++types, base += step)
196                 printk(KERN_INFO "MTRR %05X-%05X %s\n",
197                         base, base + step - 1, mtrr_attrib_to_str(*types));
198 }
199
200 static void prepare_set(void);
201 static void post_set(void);
202
203 /*  Grab all of the MTRR state for this CPU into *state  */
204 void __init get_mtrr_state(void)
205 {
206         unsigned int i;
207         struct mtrr_var_range *vrs;
208         unsigned lo, dummy;
209         unsigned long flags;
210
211         vrs = mtrr_state.var_ranges;
212
213         rdmsr(MTRRcap_MSR, lo, dummy);
214         mtrr_state.have_fixed = (lo >> 8) & 1;
215
216         for (i = 0; i < num_var_ranges; i++)
217                 get_mtrr_var_range(i, &vrs[i]);
218         if (mtrr_state.have_fixed)
219                 get_fixed_ranges(mtrr_state.fixed_ranges);
220
221         rdmsr(MTRRdefType_MSR, lo, dummy);
222         mtrr_state.def_type = (lo & 0xff);
223         mtrr_state.enabled = (lo & 0xc00) >> 10;
224
225         if (amd_special_default_mtrr()) {
226                 unsigned low, high;
227                 /* TOP_MEM2 */
228                 rdmsr(MSR_K8_TOP_MEM2, low, high);
229                 mtrr_tom2 = high;
230                 mtrr_tom2 <<= 32;
231                 mtrr_tom2 |= low;
232                 mtrr_tom2 &= 0xffffff800000ULL;
233         }
234         if (mtrr_show) {
235                 int high_width;
236
237                 printk(KERN_INFO "MTRR default type: %s\n", mtrr_attrib_to_str(mtrr_state.def_type));
238                 if (mtrr_state.have_fixed) {
239                         printk(KERN_INFO "MTRR fixed ranges %sabled:\n",
240                                mtrr_state.enabled & 1 ? "en" : "dis");
241                         print_fixed(0x00000, 0x10000, mtrr_state.fixed_ranges + 0);
242                         for (i = 0; i < 2; ++i)
243                                 print_fixed(0x80000 + i * 0x20000, 0x04000, mtrr_state.fixed_ranges + (i + 1) * 8);
244                         for (i = 0; i < 8; ++i)
245                                 print_fixed(0xC0000 + i * 0x08000, 0x01000, mtrr_state.fixed_ranges + (i + 3) * 8);
246                 }
247                 printk(KERN_INFO "MTRR variable ranges %sabled:\n",
248                        mtrr_state.enabled & 2 ? "en" : "dis");
249                 high_width = ((size_or_mask ? ffs(size_or_mask) - 1 : 32) - (32 - PAGE_SHIFT) + 3) / 4;
250                 for (i = 0; i < num_var_ranges; ++i) {
251                         if (mtrr_state.var_ranges[i].mask_lo & (1 << 11))
252                                 printk(KERN_INFO "MTRR %u base %0*X%05X000 mask %0*X%05X000 %s\n",
253                                        i,
254                                        high_width,
255                                        mtrr_state.var_ranges[i].base_hi,
256                                        mtrr_state.var_ranges[i].base_lo >> 12,
257                                        high_width,
258                                        mtrr_state.var_ranges[i].mask_hi,
259                                        mtrr_state.var_ranges[i].mask_lo >> 12,
260                                        mtrr_attrib_to_str(mtrr_state.var_ranges[i].base_lo & 0xff));
261                         else
262                                 printk(KERN_INFO "MTRR %u disabled\n", i);
263                 }
264                 if (mtrr_tom2) {
265                         printk(KERN_INFO "TOM2: %016llx aka %lldM\n",
266                                           mtrr_tom2, mtrr_tom2>>20);
267                 }
268         }
269         mtrr_state_set = 1;
270
271         /* PAT setup for BP. We need to go through sync steps here */
272         local_irq_save(flags);
273         prepare_set();
274
275         pat_init();
276
277         post_set();
278         local_irq_restore(flags);
279
280 }
281
282 /*  Some BIOS's are fucked and don't set all MTRRs the same!  */
283 void __init mtrr_state_warn(void)
284 {
285         unsigned long mask = smp_changes_mask;
286
287         if (!mask)
288                 return;
289         if (mask & MTRR_CHANGE_MASK_FIXED)
290                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent fixed MTRR settings\n");
291         if (mask & MTRR_CHANGE_MASK_VARIABLE)
292                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent variable MTRR settings\n");
293         if (mask & MTRR_CHANGE_MASK_DEFTYPE)
294                 printk(KERN_WARNING "mtrr: your CPUs had inconsistent MTRRdefType settings\n");
295         printk(KERN_INFO "mtrr: probably your BIOS does not setup all CPUs.\n");
296         printk(KERN_INFO "mtrr: corrected configuration.\n");
297 }
298
299 /* Doesn't attempt to pass an error out to MTRR users
300    because it's quite complicated in some cases and probably not
301    worth it because the best error handling is to ignore it. */
302 void mtrr_wrmsr(unsigned msr, unsigned a, unsigned b)
303 {
304         if (wrmsr_safe(msr, a, b) < 0)
305                 printk(KERN_ERR
306                         "MTRR: CPU %u: Writing MSR %x to %x:%x failed\n",
307                         smp_processor_id(), msr, a, b);
308 }
309
310 /**
311  * Enable and allow read/write of extended fixed-range MTRR bits on K8 CPUs
312  * see AMD publication no. 24593, chapter 3.2.1 for more information
313  */
314 static inline void k8_enable_fixed_iorrs(void)
315 {
316         unsigned lo, hi;
317
318         rdmsr(MSR_K8_SYSCFG, lo, hi);
319         mtrr_wrmsr(MSR_K8_SYSCFG, lo
320                                 | K8_MTRRFIXRANGE_DRAM_ENABLE
321                                 | K8_MTRRFIXRANGE_DRAM_MODIFY, hi);
322 }
323
324 /**
325  * set_fixed_range - checks & updates a fixed-range MTRR if it differs from the value it should have
326  * @msr: MSR address of the MTTR which should be checked and updated
327  * @changed: pointer which indicates whether the MTRR needed to be changed
328  * @msrwords: pointer to the MSR values which the MSR should have
329  *
330  * If K8 extentions are wanted, update the K8 SYSCFG MSR also.
331  * See AMD publication no. 24593, chapter 7.8.1, page 233 for more information.
332  */
333 static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords)
334 {
335         unsigned lo, hi;
336
337         rdmsr(msr, lo, hi);
338
339         if (lo != msrwords[0] || hi != msrwords[1]) {
340                 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
341                     (boot_cpu_data.x86 >= 0x0f && boot_cpu_data.x86 <= 0x11) &&
342                     ((msrwords[0] | msrwords[1]) & K8_MTRR_RDMEM_WRMEM_MASK))
343                         k8_enable_fixed_iorrs();
344                 mtrr_wrmsr(msr, msrwords[0], msrwords[1]);
345                 *changed = true;
346         }
347 }
348
349 /**
350  * generic_get_free_region - Get a free MTRR.
351  * @base: The starting (base) address of the region.
352  * @size: The size (in bytes) of the region.
353  * @replace_reg: mtrr index to be replaced; set to invalid value if none.
354  *
355  * Returns: The index of the region on success, else negative on error.
356  */
357 int generic_get_free_region(unsigned long base, unsigned long size, int replace_reg)
358 {
359         int i, max;
360         mtrr_type ltype;
361         unsigned long lbase, lsize;
362
363         max = num_var_ranges;
364         if (replace_reg >= 0 && replace_reg < max)
365                 return replace_reg;
366         for (i = 0; i < max; ++i) {
367                 mtrr_if->get(i, &lbase, &lsize, &ltype);
368                 if (lsize == 0)
369                         return i;
370         }
371         return -ENOSPC;
372 }
373
374 static void generic_get_mtrr(unsigned int reg, unsigned long *base,
375                              unsigned long *size, mtrr_type *type)
376 {
377         unsigned int mask_lo, mask_hi, base_lo, base_hi;
378         unsigned int tmp, hi;
379
380         rdmsr(MTRRphysMask_MSR(reg), mask_lo, mask_hi);
381         if ((mask_lo & 0x800) == 0) {
382                 /*  Invalid (i.e. free) range  */
383                 *base = 0;
384                 *size = 0;
385                 *type = 0;
386                 return;
387         }
388
389         rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi);
390
391         /* Work out the shifted address mask. */
392         tmp = mask_hi << (32 - PAGE_SHIFT) | mask_lo >> PAGE_SHIFT;
393         mask_lo = size_or_mask | tmp;
394         /* Expand tmp with high bits to all 1s*/
395         hi = fls(tmp);
396         if (hi > 0) {
397                 tmp |= ~((1<<(hi - 1)) - 1);
398
399                 if (tmp != mask_lo) {
400                         WARN_ONCE(1, KERN_INFO "mtrr: your BIOS has set up an incorrect mask, fixing it up.\n");
401                         mask_lo = tmp;
402                 }
403         }
404
405         /* This works correctly if size is a power of two, i.e. a
406            contiguous range. */
407         *size = -mask_lo;
408         *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT;
409         *type = base_lo & 0xff;
410 }
411
412 /**
413  * set_fixed_ranges - checks & updates the fixed-range MTRRs if they differ from the saved set
414  * @frs: pointer to fixed-range MTRR values, saved by get_fixed_ranges()
415  */
416 static int set_fixed_ranges(mtrr_type * frs)
417 {
418         unsigned long long *saved = (unsigned long long *) frs;
419         bool changed = false;
420         int block=-1, range;
421
422         while (fixed_range_blocks[++block].ranges)
423             for (range=0; range < fixed_range_blocks[block].ranges; range++)
424                 set_fixed_range(fixed_range_blocks[block].base_msr + range,
425                     &changed, (unsigned int *) saved++);
426
427         return changed;
428 }
429
430 /*  Set the MSR pair relating to a var range. Returns TRUE if
431     changes are made  */
432 static bool set_mtrr_var_ranges(unsigned int index, struct mtrr_var_range *vr)
433 {
434         unsigned int lo, hi;
435         bool changed = false;
436
437         rdmsr(MTRRphysBase_MSR(index), lo, hi);
438         if ((vr->base_lo & 0xfffff0ffUL) != (lo & 0xfffff0ffUL)
439             || (vr->base_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
440                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
441                 mtrr_wrmsr(MTRRphysBase_MSR(index), vr->base_lo, vr->base_hi);
442                 changed = true;
443         }
444
445         rdmsr(MTRRphysMask_MSR(index), lo, hi);
446
447         if ((vr->mask_lo & 0xfffff800UL) != (lo & 0xfffff800UL)
448             || (vr->mask_hi & (size_and_mask >> (32 - PAGE_SHIFT))) !=
449                 (hi & (size_and_mask >> (32 - PAGE_SHIFT)))) {
450                 mtrr_wrmsr(MTRRphysMask_MSR(index), vr->mask_lo, vr->mask_hi);
451                 changed = true;
452         }
453         return changed;
454 }
455
456 static u32 deftype_lo, deftype_hi;
457
458 /**
459  * set_mtrr_state - Set the MTRR state for this CPU.
460  *
461  * NOTE: The CPU must already be in a safe state for MTRR changes.
462  * RETURNS: 0 if no changes made, else a mask indicating what was changed.
463  */
464 static unsigned long set_mtrr_state(void)
465 {
466         unsigned int i;
467         unsigned long change_mask = 0;
468
469         for (i = 0; i < num_var_ranges; i++)
470                 if (set_mtrr_var_ranges(i, &mtrr_state.var_ranges[i]))
471                         change_mask |= MTRR_CHANGE_MASK_VARIABLE;
472
473         if (mtrr_state.have_fixed && set_fixed_ranges(mtrr_state.fixed_ranges))
474                 change_mask |= MTRR_CHANGE_MASK_FIXED;
475
476         /*  Set_mtrr_restore restores the old value of MTRRdefType,
477            so to set it we fiddle with the saved value  */
478         if ((deftype_lo & 0xff) != mtrr_state.def_type
479             || ((deftype_lo & 0xc00) >> 10) != mtrr_state.enabled) {
480                 deftype_lo = (deftype_lo & ~0xcff) | mtrr_state.def_type | (mtrr_state.enabled << 10);
481                 change_mask |= MTRR_CHANGE_MASK_DEFTYPE;
482         }
483
484         return change_mask;
485 }
486
487
488 static unsigned long cr4 = 0;
489 static DEFINE_SPINLOCK(set_atomicity_lock);
490
491 /*
492  * Since we are disabling the cache don't allow any interrupts - they
493  * would run extremely slow and would only increase the pain.  The caller must
494  * ensure that local interrupts are disabled and are reenabled after post_set()
495  * has been called.
496  */
497
498 static void prepare_set(void) __acquires(set_atomicity_lock)
499 {
500         unsigned long cr0;
501
502         /*  Note that this is not ideal, since the cache is only flushed/disabled
503            for this CPU while the MTRRs are changed, but changing this requires
504            more invasive changes to the way the kernel boots  */
505
506         spin_lock(&set_atomicity_lock);
507
508         /*  Enter the no-fill (CD=1, NW=0) cache mode and flush caches. */
509         cr0 = read_cr0() | X86_CR0_CD;
510         write_cr0(cr0);
511         wbinvd();
512
513         /*  Save value of CR4 and clear Page Global Enable (bit 7)  */
514         if ( cpu_has_pge ) {
515                 cr4 = read_cr4();
516                 write_cr4(cr4 & ~X86_CR4_PGE);
517         }
518
519         /* Flush all TLBs via a mov %cr3, %reg; mov %reg, %cr3 */
520         __flush_tlb();
521
522         /*  Save MTRR state */
523         rdmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
524
525         /*  Disable MTRRs, and set the default type to uncached  */
526         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo & ~0xcff, deftype_hi);
527 }
528
529 static void post_set(void) __releases(set_atomicity_lock)
530 {
531         /*  Flush TLBs (no need to flush caches - they are disabled)  */
532         __flush_tlb();
533
534         /* Intel (P6) standard MTRRs */
535         mtrr_wrmsr(MTRRdefType_MSR, deftype_lo, deftype_hi);
536                 
537         /*  Enable caches  */
538         write_cr0(read_cr0() & 0xbfffffff);
539
540         /*  Restore value of CR4  */
541         if ( cpu_has_pge )
542                 write_cr4(cr4);
543         spin_unlock(&set_atomicity_lock);
544 }
545
546 static void generic_set_all(void)
547 {
548         unsigned long mask, count;
549         unsigned long flags;
550
551         local_irq_save(flags);
552         prepare_set();
553
554         /* Actually set the state */
555         mask = set_mtrr_state();
556
557         /* also set PAT */
558         pat_init();
559
560         post_set();
561         local_irq_restore(flags);
562
563         /*  Use the atomic bitops to update the global mask  */
564         for (count = 0; count < sizeof mask * 8; ++count) {
565                 if (mask & 0x01)
566                         set_bit(count, &smp_changes_mask);
567                 mask >>= 1;
568         }
569         
570 }
571
572 static void generic_set_mtrr(unsigned int reg, unsigned long base,
573                              unsigned long size, mtrr_type type)
574 /*  [SUMMARY] Set variable MTRR register on the local CPU.
575     <reg> The register to set.
576     <base> The base address of the region.
577     <size> The size of the region. If this is 0 the region is disabled.
578     <type> The type of the region.
579     [RETURNS] Nothing.
580 */
581 {
582         unsigned long flags;
583         struct mtrr_var_range *vr;
584
585         vr = &mtrr_state.var_ranges[reg];
586
587         local_irq_save(flags);
588         prepare_set();
589
590         if (size == 0) {
591                 /* The invalid bit is kept in the mask, so we simply clear the
592                    relevant mask register to disable a range. */
593                 mtrr_wrmsr(MTRRphysMask_MSR(reg), 0, 0);
594                 memset(vr, 0, sizeof(struct mtrr_var_range));
595         } else {
596                 vr->base_lo = base << PAGE_SHIFT | type;
597                 vr->base_hi = (base & size_and_mask) >> (32 - PAGE_SHIFT);
598                 vr->mask_lo = -size << PAGE_SHIFT | 0x800;
599                 vr->mask_hi = (-size & size_and_mask) >> (32 - PAGE_SHIFT);
600
601                 mtrr_wrmsr(MTRRphysBase_MSR(reg), vr->base_lo, vr->base_hi);
602                 mtrr_wrmsr(MTRRphysMask_MSR(reg), vr->mask_lo, vr->mask_hi);
603         }
604
605         post_set();
606         local_irq_restore(flags);
607 }
608
609 int generic_validate_add_page(unsigned long base, unsigned long size, unsigned int type)
610 {
611         unsigned long lbase, last;
612
613         /*  For Intel PPro stepping <= 7, must be 4 MiB aligned 
614             and not touch 0x70000000->0x7003FFFF */
615         if (is_cpu(INTEL) && boot_cpu_data.x86 == 6 &&
616             boot_cpu_data.x86_model == 1 &&
617             boot_cpu_data.x86_mask <= 7) {
618                 if (base & ((1 << (22 - PAGE_SHIFT)) - 1)) {
619                         printk(KERN_WARNING "mtrr: base(0x%lx000) is not 4 MiB aligned\n", base);
620                         return -EINVAL;
621                 }
622                 if (!(base + size < 0x70000 || base > 0x7003F) &&
623                     (type == MTRR_TYPE_WRCOMB
624                      || type == MTRR_TYPE_WRBACK)) {
625                         printk(KERN_WARNING "mtrr: writable mtrr between 0x70000000 and 0x7003FFFF may hang the CPU.\n");
626                         return -EINVAL;
627                 }
628         }
629
630         /*  Check upper bits of base and last are equal and lower bits are 0
631             for base and 1 for last  */
632         last = base + size - 1;
633         for (lbase = base; !(lbase & 1) && (last & 1);
634              lbase = lbase >> 1, last = last >> 1) ;
635         if (lbase != last) {
636                 printk(KERN_WARNING "mtrr: base(0x%lx000) is not aligned on a size(0x%lx000) boundary\n",
637                        base, size);
638                 return -EINVAL;
639         }
640         return 0;
641 }
642
643
644 static int generic_have_wrcomb(void)
645 {
646         unsigned long config, dummy;
647         rdmsr(MTRRcap_MSR, config, dummy);
648         return (config & (1 << 10));
649 }
650
651 int positive_have_wrcomb(void)
652 {
653         return 1;
654 }
655
656 /* generic structure...
657  */
658 struct mtrr_ops generic_mtrr_ops = {
659         .use_intel_if      = 1,
660         .set_all           = generic_set_all,
661         .get               = generic_get_mtrr,
662         .get_free_region   = generic_get_free_region,
663         .set               = generic_set_mtrr,
664         .validate_add_page = generic_validate_add_page,
665         .have_wrcomb       = generic_have_wrcomb,
666 };