Subversion Repositories or1k

/*

 *      Read and write Memory Type Range Registers (MTRRs)

 *

 *      These machine specific registers contain information about

 *      caching of memory regions on Intel processors.

 *

 *      This code has been derived from pform_mod.c by M. Tisch"auser

 *      (email martin@ikcbarka.fzk.de). Special thanks to mingo for

 *      his hint.

 *

 *      (c) 1997 M. Ohlenroth <moh@informatik.tu-chemnitz.de>

 *      NO WARRANTY: use this code at your own risk!

 *

 *      This code is released under the GNU public license version 2 or

 *      later.

 *

 *      modified to have a /proc/mtrr interface by M. Fr"ohlich, Jan. 1998

 *      <frohlich@na.uni-tuebingen.de>

 *         the user Interface is partly taken form mtrr-patch-v1.5

 *      Richard Gooch may be reached by email at  rgooch@atnf.csiro.au

 *        The postal address is:

 *      Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.

 *

 */

#include <linux/kernel.h>

#include <linux/ctype.h>

#include <linux/proc_fs.h>

#include <linux/smp.h>

#include <linux/interrupt.h>

#include <asm/system.h>

#include <asm/processor.h>

#include <asm/mtrr.h>

#define MTRR_CAP        0x0fe   /* MTRRcap register */

#define MTRR_VARIABLE   0x200   /* variable length registers */

#define MTRR_FIXED64K   0x250   /* fixed size registers 64k */

#define MTRR_FIXED16K   0x258   /* fixed size registers 16K */

#define MTRR_FIXED4K    0x268   /* fixed size registers 4K */

#define MTRR_DEFTYPE    0x2ff   /* MTRRdefType register */

/*

 * data type for the MTRRcap register

 */

typedef struct {

        __u64   VCNT          :  8  __attribute__ ((packed)),

                FIX           :  1  __attribute__ ((packed)),

                __reserved_2  :  1  __attribute__ ((packed)),

                WC            :  1  __attribute__ ((packed)),

                __reserved_1  :  53 __attribute__ ((packed));

} MTRRcap_t __attribute__ ((packed));

/*

 * data type for the MTRRdefType register

 */

typedef struct {

        __u64   Type          :  8  __attribute__ ((packed)),

                __reserved_1  :  2  __attribute__ ((packed)),

                FE            :  1  __attribute__ ((packed)),

                E             :  1  __attribute__ ((packed)),

                __reserved_2  :  52 __attribute__ ((packed));

} MTRRdefType_t __attribute__ ((packed));

/* FIXME implement the entry struct */

typedef struct MTRRfix64K_t {

        __u64   raw;

} MTRRfix64K_t __attribute__ ((packed));

typedef struct MTRRfix16K_t {

        __u64   raw;

} MTRRfix16K_t __attribute__ ((packed));

typedef struct MTRRfix4K_t {

        __u64   raw;

} MTRRfix4K_t __attribute__ ((packed));

/*

 * data type for a pair of variable MTRR registers

 */

typedef struct {

        struct {

                __u64   Type          :  8  __attribute__ ((packed)),

                        __reserved_1  :  4  __attribute__ ((packed)),

                        PhysBase      :  24 __attribute__ ((packed)),

                        __reserved_2  :  28 __attribute__ ((packed));

        } MTRRphysBase  __attribute__ ((packed));

        struct {

                __u64   __reserved_3  :  11 __attribute__ ((packed)),

                        V             :  1  __attribute__ ((packed)),

                        PhysMask      :  24 __attribute__ ((packed)),

                        __reserved_4  :  28 __attribute__ ((packed));

        } MTRRphysMask __attribute__ ((packed));

} MTRRvar_t __attribute__ ((packed));

#define RAW_ACCESS64(data) (*(unsigned long long *)(&(data)))

/*

 * MTRR configuration struct

 */

struct mtrr_cntl_t {

        MTRRcap_t      MTRRcap;     /* MTRR capability register */

        MTRRdefType_t  MTRRdefType; /* MTRR default type register */

        MTRRfix64K_t   fixed64;     /* fixed length entries (raw data) */

        MTRRfix16K_t   fixed16[2];

        MTRRfix4K_t    fixed4[8];

        MTRRvar_t      variable[0]; /* variable type entries */

};

static struct mtrr_cntl_t *mtrrcntl      = NULL;

/*

 * Deletes the variable MTRR *MTRRvar

 */

static inline void MTRRvar_delete(MTRRvar_t *MTRRvar)

{

        RAW_ACCESS64(MTRRvar->MTRRphysBase) = 0;

        RAW_ACCESS64(MTRRvar->MTRRphysMask) = 0;

}

/*

 * Sets the variable MTRR *MTRRvar

 */

static inline void MTRRvar_set(MTRRvar_t *MTRRvar, unsigned int type,

                               unsigned long base, unsigned long size)

{

        unsigned long val;

        base >>= 12;

        size >>= 12;

        MTRRvar->MTRRphysBase.Type = type;

        MTRRvar->MTRRphysBase.PhysBase = base;

        MTRRvar->MTRRphysMask.V = 1;

        val = 1<<25;

        while (0 == (val & size)) val |= (val>>1);

        MTRRvar->MTRRphysMask.PhysMask = val;

}

/*

 * returns 1 if the variable MTRR entry *MTRRvar is valid, 0 otherwise

 */

static inline int MTRRvar_is_valid(const MTRRvar_t *MTRRvar)

{

        return MTRRvar->MTRRphysMask.V;

}

/*

 * returns the type of the variable MTRR entry *MTRRvar

 */

static inline int MTRRvar_get_type(const MTRRvar_t *MTRRvar)

{

        return MTRRvar->MTRRphysBase.Type;

}

/*

 * returns the base of the variable MTRR entry *MTRRvar

 */

static inline unsigned long long MTRRvar_get_base(const MTRRvar_t *MTRRvar)

{

        return ((unsigned long long)MTRRvar->MTRRphysBase.PhysBase) << 12;

}

/*

 * returns the size of the variable MTRR entry *MTRRvar

 */

static inline unsigned long long MTRRvar_get_size(const MTRRvar_t *MTRRvar)

{

        if (MTRRvar->MTRRphysMask.PhysMask == 0) {

                return 0;

        } else {

                unsigned long size = 1;

                const unsigned long Mask = MTRRvar->MTRRphysMask.PhysMask;

                while (0 == (Mask & size)) size <<= 1;

                return ((unsigned long long)size) << 12;

        }

}

/*

 *  returns the eflags register

 */

static inline int read_eflags(void)

{

        int ret;

        asm volatile (

                "pushfl\n\t"

                "popl %%eax\n\t"

                :"=a" (ret)

                :

                );

        return ret;

}

/*

 *  writes the eflags register

 */

static inline void write_eflags(int flag)

{

        asm volatile (

                "pushl %%eax\n\t"

                "popfl\n\t"

                :

                :"a" (flag)

                );

}

/*

 * returns 1 if the mtrr's are supported by the current processor, 0 otherwise

 */

static inline int mtrr_detect(void) {

        unsigned long flags;

        int eflags;

        int val;

#define MSR_MASK 0x20

#define MTRR_MASK 0x1000

#define CPUID_MASK 0x200000

        /* this function may be called before the cpu_data array has

                been initialized */

        save_flags(flags); sti();

        eflags = read_eflags();

        write_eflags(eflags ^ CPUID_MASK);

        if (!((eflags ^ read_eflags()) & CPUID_MASK)) {

                write_eflags(eflags);

                restore_flags(flags);

                return 0;

        }

        write_eflags(eflags);

        restore_flags(flags);

        /* get the cpuid level */

        asm volatile (

                "xorl %%eax,%%eax\n\t"

                "cpuid"

                :"=a"(val)::"ebx","ecx","edx"

        );

        if (val < 1) return 0;

        /* get the x86_capability value */

        asm volatile (

                "movl $1,%%eax\n\t"

                "cpuid"

                :"=d"(val)::"ebx","ecx","eax"

        );

        if (!(val & MSR_MASK)) return 0;

        if (!(val & MTRR_MASK)) return 0;

        return 1;

#undef MSR_MASK

#undef MTRR_MASK

#undef CPUID_MASK

}

/*

 * reads the mtrr configuration of the actual processor and returns

 * this configuration on sucess. returns NULL if an error occured or

 * if mtrr's are not supported.

 */

static struct mtrr_cntl_t *read_mtrr_configuration (void) {

        struct mtrr_cntl_t *mtrrcntl;

        int i;

        size_t size;

        MTRRcap_t MTRRcap;

        if (!mtrr_detect()) {

                printk("/proc/mtrr: MTRR's are NOT supported\n");

                return NULL;

        }

        RAW_ACCESS64(MTRRcap) = rdmsr(MTRR_CAP);

/* #define DUMP_MTRR */

#ifdef DUMP_MTRR

        {

                /* Written for a bugreport to Gigabyte ... */

                inline void print_msr(int num) {

                        unsigned long long tmp = rdmsr(num);

                        printk("MSR #%#06x: 0x%08lx%08lx\n",

                               num , (unsigned long)(tmp >> 32),

                               (unsigned long)tmp);

                }

                print_msr(MTRR_CAP);

                /* all variable type */

                for (i=0;i < MTRRcap.VCNT;i++) {

                        print_msr(MTRR_VARIABLE+2*i);

                        print_msr(MTRR_VARIABLE+2*i+1);

                }

                /* all fixed type */

                print_msr(MTRR_FIXED64K);

                print_msr(MTRR_FIXED16K);

                print_msr(MTRR_FIXED16K+1);

                for (i=0;i<8;i++)

                        print_msr(MTRR_FIXED4K+i);

                print_msr(MTRR_DEFTYPE);

        }

#endif

        size = sizeof(struct mtrr_cntl_t) + sizeof(MTRRvar_t)*MTRRcap.VCNT;

        if (NULL == (mtrrcntl = kmalloc(size, GFP_KERNEL))) return NULL;

        memset(mtrrcntl, 0, size);

        /* read MTRRcap register */

        mtrrcntl->MTRRcap = MTRRcap;

        /* read MTRRdefType register */

        RAW_ACCESS64(mtrrcntl->MTRRdefType) = rdmsr(MTRR_DEFTYPE);

        /* read fixed length entries */

        if (mtrrcntl->MTRRdefType.E && mtrrcntl->MTRRdefType.FE) {

                mtrrcntl->fixed64.raw = rdmsr(MTRR_FIXED64K);

                mtrrcntl->fixed16[0].raw = rdmsr(MTRR_FIXED16K);

                mtrrcntl->fixed16[1].raw = rdmsr(MTRR_FIXED16K+1);

                for (i=0;i<8;i++)

                        mtrrcntl->fixed4[i].raw = rdmsr(MTRR_FIXED4K+i);

        }

        /* read variable length entries */

        if (mtrrcntl->MTRRdefType.E) {

                const int vcnt = mtrrcntl->MTRRcap.VCNT;

                for (i = 0 ; i < vcnt ; i++) {

                        RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysBase) =

                                rdmsr(MTRR_VARIABLE + 2*i);

                        RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysMask) =

                                rdmsr(MTRR_VARIABLE + 2*i + 1);

                }

        }

        return mtrrcntl;

}

/*

 * initializes the global mtrr configuration

 */

/*__init_function(void init_mtrr_config(void)) FIXME*/

void init_mtrr_config(void)

{

        mtrrcntl = read_mtrr_configuration();

}

/* write back and invalidate cache */

static inline void wbinvd(void)

{

        asm volatile("wbinvd");

}

/* flush tlb's */

static inline void flush__tlb(void)

{

        asm volatile (

                "movl  %%cr3, %%eax\n\t"

                "movl  %%eax, %%cr3\n\t"

                :

                :

                : "memory", "eax");

}

/* clear page global enable and return previous value */

static inline unsigned long clear_pge(void)

{

        unsigned long ret;

        asm volatile (

                "movl  %%cr4, %%eax\n\t"

                "movl  %%eax, %%edx\n\t"

                "andl  $0x7f, %%edx\n\t"

                "movl  %%edx, %%cr4\n\t"

                : "=a" (ret)

                :

                : "memory", "cc", "eax", "edx");

        return ret;

}

/* restores page global enable bit */

static inline void restore_pge(unsigned long cr4)

{

        asm volatile (

                "movl  %0, %%cr4\n\t"

                :

                : "r" (cr4)

                : "memory");

}

/* ... */

static inline void disable_cache(void)

{

        asm volatile (

                "movl  %%cr0, %%eax\n\t"

                "orl   $0x40000000, %%eax\n\t"

                "movl  %%eax, %%cr0\n\t"

                :

                :

                :"memory", "cc", "eax");

}

/* ... */

static inline void enable_cache(void)

{

        asm volatile (

                "movl  %%cr0, %%eax\n\t"

                "andl  $0xbfffffff, %%eax\n\t"

                "movl  %%eax, %%cr0"

                :

                :

                :"memory", "cc", "eax");

}

/* clear the MTRRdefType.E and MTRRdefType.FE flag to disable these MTRR's */

static inline void disable_mtrr(void)

{

        MTRRdefType_t MTRRdefType;

        RAW_ACCESS64(MTRRdefType) = rdmsr(MTRR_DEFTYPE);

        MTRRdefType.E = 0;

        MTRRdefType.FE = 0;

        wrmsr(MTRR_DEFTYPE, RAW_ACCESS64(MTRRdefType));

}

/*

 * written from pseudocode from intel

 *  (PentiumPro Family Developers manual Volume 3, P 322)

 *

 */

static inline unsigned long pre_mtrr_change(void)

{

        unsigned long cr4;

        cr4 = clear_pge();

        wbinvd();

        disable_cache();

        wbinvd();

        flush__tlb();

        disable_mtrr();

        return cr4;

}

/*

 * written from pseudocode from intel

 *  (PentiumPro Family Developers manual Volume 3, P 322)

 */

static inline void post_mtrr_change(MTRRdefType_t MTRRdefType,unsigned long cr4)

{

        wbinvd();

        flush__tlb();

        wrmsr(MTRR_DEFTYPE, RAW_ACCESS64(MTRRdefType));

        enable_cache();

        restore_pge(cr4);

}

/*

 * writes all fixed mtrr's

 */

static inline void set_mtrr_fixed(void) {

        int i;

        wrmsr(MTRR_FIXED64K,mtrrcntl->fixed64.raw);

        wrmsr(MTRR_FIXED16K+0,mtrrcntl->fixed16[0].raw);

        wrmsr(MTRR_FIXED16K+1,mtrrcntl->fixed16[1].raw);

        for (i=0;i<8;i++)

                wrmsr(MTRR_FIXED4K+i,mtrrcntl->fixed4[i].raw);

}

/*

 * writes all variable mtrr's

 */

static inline void set_mtrr_variable(void) {

        int i;

        const int vcnt = mtrrcntl->MTRRcap.VCNT;

        for (i = 0 ; i < vcnt ; i++ ) {

                wrmsr(MTRR_VARIABLE +2*i,

                      RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysBase));

                wrmsr(MTRR_VARIABLE +2*i+1,

                      RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysMask));

        }

}

/*

 * compares the mtrr_cntl_t structure second with that set by

 * the boot processor,

 * returns 0 if equal,

 *        -1 if the structs are not initialized,

 *         1 if they are different

 *

 * the *second struct is assumed to be local, it is not locked!

 */

static inline int compare_mtrr_configuration(struct mtrr_cntl_t *second) {

        int i, result = 0;

        if (NULL == mtrrcntl) { result = -1; goto end; }

        if (NULL == second) { result = -1; goto end; }

        if (RAW_ACCESS64(mtrrcntl->MTRRcap)

            != RAW_ACCESS64(second->MTRRcap)) {

                result = 1; goto end;

        }

        if (RAW_ACCESS64(mtrrcntl->MTRRdefType)

            != RAW_ACCESS64(second->MTRRdefType)) {

                result = 1; goto end;

        }

        if (mtrrcntl->fixed64.raw != second->fixed64.raw) {

                result = 1; goto end;

        }

        if (mtrrcntl->fixed16[0].raw != second->fixed16[0].raw) {

                result = 1; goto end;

        }

        if (mtrrcntl->fixed16[1].raw != second->fixed16[1].raw) {

                result = 1; goto end;

        }

        for (i=0;i<8;i++)

                if (mtrrcntl->fixed4[i].raw != second->fixed4[i].raw) {

                        result = 1; goto end;

                }

        {

                const int vcnt = mtrrcntl->MTRRcap.VCNT;

                for (i = 0; i < vcnt; i++) {

                        if (RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysBase) !=

                            RAW_ACCESS64(second->variable[i].MTRRphysBase)) {

                                result = 1; goto end;

                        }

                        if (RAW_ACCESS64(mtrrcntl->variable[i].MTRRphysMask) !=

                            RAW_ACCESS64(second->variable[i].MTRRphysMask)) {

                                result = 1; goto end;

                        }

                }

        }

        end:

        return result;

}

/*

 * compares the mtrr configuration of the current processor with the

 * main configuration and overwrites the mtrr's in the processor if they

 * differ. (fixes a bug in the GA-686DX mainboard BIOS)

 */

void check_mtrr_config(void) {

        unsigned long cr4;

        unsigned long flags;

        struct mtrr_cntl_t *this_cpu_setting;

        int result;

        save_flags(flags); sti();

        /* if global struct is not initialized return */

        if (mtrrcntl == NULL) {

                restore_flags(flags);

                return;

        }

        /* disable MTRR feature if this_cpu_setting == NULL */

        /* read mtrr configuration of this cpu */

        this_cpu_setting = read_mtrr_configuration();

        if (this_cpu_setting == NULL) {

                printk("/proc/mtrr: MTRR's are NOT supported by cpu %i.\n",

                       smp_processor_id());

                restore_flags(flags);

                return;

        }

        /* compare mtrr configuration */

        result = compare_mtrr_configuration(this_cpu_setting);

        kfree(this_cpu_setting);

        /* return if mtrr setting is correct */

        if (0 >= result) {

                restore_flags(flags);

                return;

        }

        /* prepare cpu's for setting mtrr's */

        cr4 = pre_mtrr_change();

        /* set all mtrr's */

        set_mtrr_fixed();

        set_mtrr_variable();

        /* prepare cpu's for running */

        post_mtrr_change(mtrrcntl->MTRRdefType, cr4);

        restore_flags(flags);

        printk("\nBIOS bug workaround: MTRR configuration changed on cpu "

               "%i.\n", smp_processor_id());

}