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