arch/x86/lib/msr.c

   1 #include <linux/module.h>
   2 #include <linux/preempt.h>
   3 #include <linux/smp.h>
   4 #include <asm/msr.h>
   5
   6 struct msr_info {
   7         u32 msr_no;
   8         struct msr reg;
   9         struct msr *msrs;
  10         int off;
  11         int err;
  12 };
  13
  14 static void __rdmsr_on_cpu(void *info)
  15 {
  16         struct msr_info *rv = info;
  17         struct msr *reg;
  18         int this_cpu = raw_smp_processor_id();
  19
  20         if (rv->msrs)
  21                 reg = &rv->msrs[this_cpu - rv->off];
  22         else
  23                 reg = &rv->reg;
  24
  25         rdmsr(rv->msr_no, reg->l, reg->h);
  26 }
  27
  28 static void __wrmsr_on_cpu(void *info)
  29 {
  30         struct msr_info *rv = info;
  31         struct msr *reg;
  32         int this_cpu = raw_smp_processor_id();
  33
  34         if (rv->msrs)
  35                 reg = &rv->msrs[this_cpu - rv->off];
  36         else
  37                 reg = &rv->reg;
  38
  39         wrmsr(rv->msr_no, reg->l, reg->h);
  40 }
  41
  42 int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
  43 {
  44         int err;
  45         struct msr_info rv;
  46
  47         memset(&rv, 0, sizeof(rv));
  48
  49         rv.msr_no = msr_no;
  50         err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1);
  51         *l = rv.reg.l;
  52         *h = rv.reg.h;
  53
  54         return err;
  55 }
  56 EXPORT_SYMBOL(rdmsr_on_cpu);
  57
  58 int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
  59 {
  60         int err;
  61         struct msr_info rv;
  62
  63         memset(&rv, 0, sizeof(rv));
  64
  65         rv.msr_no = msr_no;
  66         rv.reg.l = l;
  67         rv.reg.h = h;
  68         err = smp_call_function_single(cpu, __wrmsr_on_cpu, &rv, 1);
  69
  70         return err;
  71 }
  72 EXPORT_SYMBOL(wrmsr_on_cpu);
  73
  74 static void __rwmsr_on_cpus(const struct cpumask *mask, u32 msr_no,
  75                             struct msr *msrs,
  76                             void (*msr_func) (void *info))
  77 {
  78         struct msr_info rv;
  79         int this_cpu;
  80
  81         memset(&rv, 0, sizeof(rv));
  82
  83         rv.off    = cpumask_first(mask);
  84         rv.msrs   = msrs;
  85         rv.msr_no = msr_no;
  86
  87         this_cpu = get_cpu();
  88
  89         if (cpumask_test_cpu(this_cpu, mask))
  90                 msr_func(&rv);
  91
  92         smp_call_function_many(mask, msr_func, &rv, 1);
  93         put_cpu();
  94 }
  95
  96 /* rdmsr on a bunch of CPUs
  97  *
  98  * @mask:       which CPUs
  99  * @msr_no:     which MSR
 100  * @msrs:       array of MSR values
 101  *
 102  */
 103 void rdmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs)
 104 {
 105         __rwmsr_on_cpus(mask, msr_no, msrs, __rdmsr_on_cpu);
 106 }
 107 EXPORT_SYMBOL(rdmsr_on_cpus);
 108
 109 /*
 110  * wrmsr on a bunch of CPUs
 111  *
 112  * @mask:       which CPUs
 113  * @msr_no:     which MSR
 114  * @msrs:       array of MSR values
 115  *
 116  */
 117 void wrmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs)
 118 {
 119         __rwmsr_on_cpus(mask, msr_no, msrs, __wrmsr_on_cpu);
 120 }
 121 EXPORT_SYMBOL(wrmsr_on_cpus);
 122
 123 /* These "safe" variants are slower and should be used when the target MSR
 124    may not actually exist. */
 125 static void __rdmsr_safe_on_cpu(void *info)
 126 {
 127         struct msr_info *rv = info;
 128
 129         rv->err = rdmsr_safe(rv->msr_no, &rv->reg.l, &rv->reg.h);
 130 }
 131
 132 static void __wrmsr_safe_on_cpu(void *info)
 133 {
 134         struct msr_info *rv = info;
 135
 136         rv->err = wrmsr_safe(rv->msr_no, rv->reg.l, rv->reg.h);
 137 }
 138
 139 int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
 140 {
 141         int err;
 142         struct msr_info rv;
 143
 144         memset(&rv, 0, sizeof(rv));
 145
 146         rv.msr_no = msr_no;
 147         err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1);
 148         *l = rv.reg.l;
 149         *h = rv.reg.h;
 150
 151         return err ? err : rv.err;
 152 }
 153 EXPORT_SYMBOL(rdmsr_safe_on_cpu);
 154
 155 int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
 156 {
 157         int err;
 158         struct msr_info rv;
 159
 160         memset(&rv, 0, sizeof(rv));
 161
 162         rv.msr_no = msr_no;
 163         rv.reg.l = l;
 164         rv.reg.h = h;
 165         err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1);
 166
 167         return err ? err : rv.err;
 168 }
 169 EXPORT_SYMBOL(wrmsr_safe_on_cpu);
 170
 171 /*
 172  * These variants are significantly slower, but allows control over
 173  * the entire 32-bit GPR set.
 174  */
 175 struct msr_regs_info {
 176         u32 *regs;
 177         int err;
 178 };
 179
 180 static void __rdmsr_safe_regs_on_cpu(void *info)
 181 {
 182         struct msr_regs_info *rv = info;
 183
 184         rv->err = rdmsr_safe_regs(rv->regs);
 185 }
 186
 187 static void __wrmsr_safe_regs_on_cpu(void *info)
 188 {
 189         struct msr_regs_info *rv = info;
 190
 191         rv->err = wrmsr_safe_regs(rv->regs);
 192 }
 193
 194 int rdmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs)
 195 {
 196         int err;
 197         struct msr_regs_info rv;
 198
 199         rv.regs   = regs;
 200         rv.err    = -EIO;
 201         err = smp_call_function_single(cpu, __rdmsr_safe_regs_on_cpu, &rv, 1);
 202
 203         return err ? err : rv.err;
 204 }
 205 EXPORT_SYMBOL(rdmsr_safe_regs_on_cpu);
 206
 207 int wrmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs)
 208 {
 209         int err;
 210         struct msr_regs_info rv;
 211
 212         rv.regs = regs;
 213         rv.err  = -EIO;
 214         err = smp_call_function_single(cpu, __wrmsr_safe_regs_on_cpu, &rv, 1);
 215
 216         return err ? err : rv.err;
 217 }
 218 EXPORT_SYMBOL(wrmsr_safe_regs_on_cpu);