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