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); 219