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 /* rdmsr on a bunch of CPUs 75 * 76 * @mask: which CPUs 77 * @msr_no: which MSR 78 * @msrs: array of MSR values 79 * 80 */ 81 void rdmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs) 82 { 83 struct msr_info rv; 84 int this_cpu; 85 86 memset(&rv, 0, sizeof(rv)); 87 88 rv.off = cpumask_first(mask); 89 rv.msrs = msrs; 90 rv.msr_no = msr_no; 91 92 this_cpu = get_cpu(); 93 94 if (cpumask_test_cpu(this_cpu, mask)) 95 __rdmsr_on_cpu(&rv); 96 97 smp_call_function_many(mask, __rdmsr_on_cpu, &rv, 1); 98 put_cpu(); 99 } 100 EXPORT_SYMBOL(rdmsr_on_cpus); 101 102 /* 103 * wrmsr on a bunch of CPUs 104 * 105 * @mask: which CPUs 106 * @msr_no: which MSR 107 * @msrs: array of MSR values 108 * 109 */ 110 void wrmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs) 111 { 112 struct msr_info rv; 113 int this_cpu; 114 115 memset(&rv, 0, sizeof(rv)); 116 117 rv.off = cpumask_first(mask); 118 rv.msrs = msrs; 119 rv.msr_no = msr_no; 120 121 this_cpu = get_cpu(); 122 123 if (cpumask_test_cpu(this_cpu, mask)) 124 __wrmsr_on_cpu(&rv); 125 126 smp_call_function_many(mask, __wrmsr_on_cpu, &rv, 1); 127 put_cpu(); 128 } 129 EXPORT_SYMBOL(wrmsr_on_cpus); 130 131 /* These "safe" variants are slower and should be used when the target MSR 132 may not actually exist. */ 133 static void __rdmsr_safe_on_cpu(void *info) 134 { 135 struct msr_info *rv = info; 136 137 rv->err = rdmsr_safe(rv->msr_no, &rv->reg.l, &rv->reg.h); 138 } 139 140 static void __wrmsr_safe_on_cpu(void *info) 141 { 142 struct msr_info *rv = info; 143 144 rv->err = wrmsr_safe(rv->msr_no, rv->reg.l, rv->reg.h); 145 } 146 147 int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h) 148 { 149 int err; 150 struct msr_info rv; 151 152 memset(&rv, 0, sizeof(rv)); 153 154 rv.msr_no = msr_no; 155 err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1); 156 *l = rv.reg.l; 157 *h = rv.reg.h; 158 159 return err ? err : rv.err; 160 } 161 EXPORT_SYMBOL(rdmsr_safe_on_cpu); 162 163 int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h) 164 { 165 int err; 166 struct msr_info rv; 167 168 memset(&rv, 0, sizeof(rv)); 169 170 rv.msr_no = msr_no; 171 rv.reg.l = l; 172 rv.reg.h = h; 173 err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); 174 175 return err ? err : rv.err; 176 } 177 EXPORT_SYMBOL(wrmsr_safe_on_cpu); 178 179 /* 180 * These variants are significantly slower, but allows control over 181 * the entire 32-bit GPR set. 182 */ 183 struct msr_regs_info { 184 u32 *regs; 185 int err; 186 }; 187 188 static void __rdmsr_safe_regs_on_cpu(void *info) 189 { 190 struct msr_regs_info *rv = info; 191 192 rv->err = rdmsr_safe_regs(rv->regs); 193 } 194 195 static void __wrmsr_safe_regs_on_cpu(void *info) 196 { 197 struct msr_regs_info *rv = info; 198 199 rv->err = wrmsr_safe_regs(rv->regs); 200 } 201 202 int rdmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs) 203 { 204 int err; 205 struct msr_regs_info rv; 206 207 rv.regs = regs; 208 rv.err = -EIO; 209 err = smp_call_function_single(cpu, __rdmsr_safe_regs_on_cpu, &rv, 1); 210 211 return err ? err : rv.err; 212 } 213 EXPORT_SYMBOL(rdmsr_safe_regs_on_cpu); 214 215 int wrmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs) 216 { 217 int err; 218 struct msr_regs_info rv; 219 220 rv.regs = regs; 221 rv.err = -EIO; 222 err = smp_call_function_single(cpu, __wrmsr_safe_regs_on_cpu, &rv, 1); 223 224 return err ? err : rv.err; 225 } 226 EXPORT_SYMBOL(wrmsr_safe_regs_on_cpu); 227