[deliverable/linux.git] / arch / x86 / lib / msr-smp.c

#include <linux/module.h>
#include <linux/preempt.h>
#include <linux/smp.h>
#include <asm/msr.h>

static void __rdmsr_on_cpu(void *info)
{
	struct msr_info *rv = info;
	struct msr *reg;
	int this_cpu = raw_smp_processor_id();

	if (rv->msrs)
		reg = per_cpu_ptr(rv->msrs, this_cpu);
	else
		reg = &rv->reg;

	rdmsr(rv->msr_no, reg->l, reg->h);
}

static void __wrmsr_on_cpu(void *info)
{
	struct msr_info *rv = info;
	struct msr *reg;
	int this_cpu = raw_smp_processor_id();

	if (rv->msrs)
		reg = per_cpu_ptr(rv->msrs, this_cpu);
	else
		reg = &rv->reg;

	wrmsr(rv->msr_no, reg->l, reg->h);
}

int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
{
	int err;
	struct msr_info rv;

	memset(&rv, 0, sizeof(rv));

	rv.msr_no = msr_no;
	err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1);
	*l = rv.reg.l;
	*h = rv.reg.h;

	return err;
}
EXPORT_SYMBOL(rdmsr_on_cpu);

int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
{
	int err;
	struct msr_info rv;

	memset(&rv, 0, sizeof(rv));

	rv.msr_no = msr_no;
	rv.reg.l = l;
	rv.reg.h = h;
	err = smp_call_function_single(cpu, __wrmsr_on_cpu, &rv, 1);

	return err;
}
EXPORT_SYMBOL(wrmsr_on_cpu);

static void __rwmsr_on_cpus(const struct cpumask *mask, u32 msr_no,
			    struct msr *msrs,
			    void (*msr_func) (void *info))
{
	struct msr_info rv;
	int this_cpu;

	memset(&rv, 0, sizeof(rv));

	rv.msrs	  = msrs;
	rv.msr_no = msr_no;

	this_cpu = get_cpu();

	if (cpumask_test_cpu(this_cpu, mask))
		msr_func(&rv);

	smp_call_function_many(mask, msr_func, &rv, 1);
	put_cpu();
}

/* rdmsr on a bunch of CPUs
 *
 * @mask:       which CPUs
 * @msr_no:     which MSR
 * @msrs:       array of MSR values
 *
 */
void rdmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs)
{
	__rwmsr_on_cpus(mask, msr_no, msrs, __rdmsr_on_cpu);
}
EXPORT_SYMBOL(rdmsr_on_cpus);

/*
 * wrmsr on a bunch of CPUs
 *
 * @mask:       which CPUs
 * @msr_no:     which MSR
 * @msrs:       array of MSR values
 *
 */
void wrmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs)
{
	__rwmsr_on_cpus(mask, msr_no, msrs, __wrmsr_on_cpu);
}
EXPORT_SYMBOL(wrmsr_on_cpus);

/* These "safe" variants are slower and should be used when the target MSR
   may not actually exist. */
static void __rdmsr_safe_on_cpu(void *info)
{
	struct msr_info *rv = info;

	rv->err = rdmsr_safe(rv->msr_no, &rv->reg.l, &rv->reg.h);
}

static void __wrmsr_safe_on_cpu(void *info)
{
	struct msr_info *rv = info;

	rv->err = wrmsr_safe(rv->msr_no, rv->reg.l, rv->reg.h);
}

int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
{
	int err;
	struct msr_info rv;

	memset(&rv, 0, sizeof(rv));

	rv.msr_no = msr_no;
	err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1);
	*l = rv.reg.l;
	*h = rv.reg.h;

	return err ? err : rv.err;
}
EXPORT_SYMBOL(rdmsr_safe_on_cpu);

int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
{
	int err;
	struct msr_info rv;

	memset(&rv, 0, sizeof(rv));

	rv.msr_no = msr_no;
	rv.reg.l = l;
	rv.reg.h = h;
	err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1);

	return err ? err : rv.err;
}
EXPORT_SYMBOL(wrmsr_safe_on_cpu);

/*
 * These variants are significantly slower, but allows control over
 * the entire 32-bit GPR set.
 */
static void __rdmsr_safe_regs_on_cpu(void *info)
{
	struct msr_regs_info *rv = info;

	rv->err = rdmsr_safe_regs(rv->regs);
}

static void __wrmsr_safe_regs_on_cpu(void *info)
{
	struct msr_regs_info *rv = info;

	rv->err = wrmsr_safe_regs(rv->regs);
}

int rdmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs)
{
	int err;
	struct msr_regs_info rv;

	rv.regs   = regs;
	rv.err    = -EIO;
	err = smp_call_function_single(cpu, __rdmsr_safe_regs_on_cpu, &rv, 1);

	return err ? err : rv.err;
}
EXPORT_SYMBOL(rdmsr_safe_regs_on_cpu);

int wrmsr_safe_regs_on_cpu(unsigned int cpu, u32 *regs)
{
	int err;
	struct msr_regs_info rv;

	rv.regs = regs;
	rv.err  = -EIO;
	err = smp_call_function_single(cpu, __wrmsr_safe_regs_on_cpu, &rv, 1);

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