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