xref: /linux/arch/powerpc/include/asm/plpar_wrappers.h (revision 0883c2c06fb5bcf5b9e008270827e63c09a88c1e) 
1 #ifndef _ASM_POWERPC_PLPAR_WRAPPERS_H
2 #define _ASM_POWERPC_PLPAR_WRAPPERS_H
3 
4 #include <linux/string.h>
5 #include <linux/irqflags.h>
6 
7 #include <asm/hvcall.h>
8 #include <asm/paca.h>
9 #include <asm/page.h>
10 
11 /* Get state of physical CPU from query_cpu_stopped */
12 int smp_query_cpu_stopped(unsigned int pcpu);
13 #define QCSS_STOPPED 0
14 #define QCSS_STOPPING 1
15 #define QCSS_NOT_STOPPED 2
16 #define QCSS_HARDWARE_ERROR -1
17 #define QCSS_HARDWARE_BUSY -2
18 
19 static inline long poll_pending(void)
20 {
21 	return plpar_hcall_norets(H_POLL_PENDING);
22 }
23 
24 static inline u8 get_cede_latency_hint(void)
25 {
26 	return get_lppaca()->cede_latency_hint;
27 }
28 
29 static inline void set_cede_latency_hint(u8 latency_hint)
30 {
31 	get_lppaca()->cede_latency_hint = latency_hint;
32 }
33 
34 static inline long cede_processor(void)
35 {
36 	return plpar_hcall_norets(H_CEDE);
37 }
38 
39 static inline long extended_cede_processor(unsigned long latency_hint)
40 {
41 	long rc;
42 	u8 old_latency_hint = get_cede_latency_hint();
43 
44 	set_cede_latency_hint(latency_hint);
45 
46 	rc = cede_processor();
47 #ifdef CONFIG_TRACE_IRQFLAGS
48 		/* Ensure that H_CEDE returns with IRQs on */
49 		if (WARN_ON(!(mfmsr() & MSR_EE)))
50 			__hard_irq_enable();
51 #endif
52 
53 	set_cede_latency_hint(old_latency_hint);
54 
55 	return rc;
56 }
57 
58 static inline long vpa_call(unsigned long flags, unsigned long cpu,
59 		unsigned long vpa)
60 {
61 	flags = flags << H_VPA_FUNC_SHIFT;
62 
63 	return plpar_hcall_norets(H_REGISTER_VPA, flags, cpu, vpa);
64 }
65 
66 static inline long unregister_vpa(unsigned long cpu)
67 {
68 	return vpa_call(H_VPA_DEREG_VPA, cpu, 0);
69 }
70 
71 static inline long register_vpa(unsigned long cpu, unsigned long vpa)
72 {
73 	return vpa_call(H_VPA_REG_VPA, cpu, vpa);
74 }
75 
76 static inline long unregister_slb_shadow(unsigned long cpu)
77 {
78 	return vpa_call(H_VPA_DEREG_SLB, cpu, 0);
79 }
80 
81 static inline long register_slb_shadow(unsigned long cpu, unsigned long vpa)
82 {
83 	return vpa_call(H_VPA_REG_SLB, cpu, vpa);
84 }
85 
86 static inline long unregister_dtl(unsigned long cpu)
87 {
88 	return vpa_call(H_VPA_DEREG_DTL, cpu, 0);
89 }
90 
91 static inline long register_dtl(unsigned long cpu, unsigned long vpa)
92 {
93 	return vpa_call(H_VPA_REG_DTL, cpu, vpa);
94 }
95 
96 static inline long plpar_page_set_loaned(unsigned long vpa)
97 {
98 	unsigned long cmo_page_sz = cmo_get_page_size();
99 	long rc = 0;
100 	int i;
101 
102 	for (i = 0; !rc && i < PAGE_SIZE; i += cmo_page_sz)
103 		rc = plpar_hcall_norets(H_PAGE_INIT, H_PAGE_SET_LOANED, vpa + i, 0);
104 
105 	for (i -= cmo_page_sz; rc && i != 0; i -= cmo_page_sz)
106 		plpar_hcall_norets(H_PAGE_INIT, H_PAGE_SET_ACTIVE,
107 				   vpa + i - cmo_page_sz, 0);
108 
109 	return rc;
110 }
111 
112 static inline long plpar_page_set_active(unsigned long vpa)
113 {
114 	unsigned long cmo_page_sz = cmo_get_page_size();
115 	long rc = 0;
116 	int i;
117 
118 	for (i = 0; !rc && i < PAGE_SIZE; i += cmo_page_sz)
119 		rc = plpar_hcall_norets(H_PAGE_INIT, H_PAGE_SET_ACTIVE, vpa + i, 0);
120 
121 	for (i -= cmo_page_sz; rc && i != 0; i -= cmo_page_sz)
122 		plpar_hcall_norets(H_PAGE_INIT, H_PAGE_SET_LOANED,
123 				   vpa + i - cmo_page_sz, 0);
124 
125 	return rc;
126 }
127 
128 extern void vpa_init(int cpu);
129 
130 static inline long plpar_pte_enter(unsigned long flags,
131 		unsigned long hpte_group, unsigned long hpte_v,
132 		unsigned long hpte_r, unsigned long *slot)
133 {
134 	long rc;
135 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
136 
137 	rc = plpar_hcall(H_ENTER, retbuf, flags, hpte_group, hpte_v, hpte_r);
138 
139 	*slot = retbuf[0];
140 
141 	return rc;
142 }
143 
144 static inline long plpar_pte_remove(unsigned long flags, unsigned long ptex,
145 		unsigned long avpn, unsigned long *old_pteh_ret,
146 		unsigned long *old_ptel_ret)
147 {
148 	long rc;
149 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
150 
151 	rc = plpar_hcall(H_REMOVE, retbuf, flags, ptex, avpn);
152 
153 	*old_pteh_ret = retbuf[0];
154 	*old_ptel_ret = retbuf[1];
155 
156 	return rc;
157 }
158 
159 /* plpar_pte_remove_raw can be called in real mode. It calls plpar_hcall_raw */
160 static inline long plpar_pte_remove_raw(unsigned long flags, unsigned long ptex,
161 		unsigned long avpn, unsigned long *old_pteh_ret,
162 		unsigned long *old_ptel_ret)
163 {
164 	long rc;
165 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
166 
167 	rc = plpar_hcall_raw(H_REMOVE, retbuf, flags, ptex, avpn);
168 
169 	*old_pteh_ret = retbuf[0];
170 	*old_ptel_ret = retbuf[1];
171 
172 	return rc;
173 }
174 
175 static inline long plpar_pte_read(unsigned long flags, unsigned long ptex,
176 		unsigned long *old_pteh_ret, unsigned long *old_ptel_ret)
177 {
178 	long rc;
179 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
180 
181 	rc = plpar_hcall(H_READ, retbuf, flags, ptex);
182 
183 	*old_pteh_ret = retbuf[0];
184 	*old_ptel_ret = retbuf[1];
185 
186 	return rc;
187 }
188 
189 /* plpar_pte_read_raw can be called in real mode. It calls plpar_hcall_raw */
190 static inline long plpar_pte_read_raw(unsigned long flags, unsigned long ptex,
191 		unsigned long *old_pteh_ret, unsigned long *old_ptel_ret)
192 {
193 	long rc;
194 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
195 
196 	rc = plpar_hcall_raw(H_READ, retbuf, flags, ptex);
197 
198 	*old_pteh_ret = retbuf[0];
199 	*old_ptel_ret = retbuf[1];
200 
201 	return rc;
202 }
203 
204 /*
205  * ptes must be 8*sizeof(unsigned long)
206  */
207 static inline long plpar_pte_read_4(unsigned long flags, unsigned long ptex,
208 				    unsigned long *ptes)
209 
210 {
211 	long rc;
212 	unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
213 
214 	rc = plpar_hcall9(H_READ, retbuf, flags | H_READ_4, ptex);
215 
216 	memcpy(ptes, retbuf, 8*sizeof(unsigned long));
217 
218 	return rc;
219 }
220 
221 /*
222  * plpar_pte_read_4_raw can be called in real mode.
223  * ptes must be 8*sizeof(unsigned long)
224  */
225 static inline long plpar_pte_read_4_raw(unsigned long flags, unsigned long ptex,
226 					unsigned long *ptes)
227 
228 {
229 	long rc;
230 	unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
231 
232 	rc = plpar_hcall9_raw(H_READ, retbuf, flags | H_READ_4, ptex);
233 
234 	memcpy(ptes, retbuf, 8*sizeof(unsigned long));
235 
236 	return rc;
237 }
238 
239 static inline long plpar_pte_protect(unsigned long flags, unsigned long ptex,
240 		unsigned long avpn)
241 {
242 	return plpar_hcall_norets(H_PROTECT, flags, ptex, avpn);
243 }
244 
245 static inline long plpar_tce_get(unsigned long liobn, unsigned long ioba,
246 		unsigned long *tce_ret)
247 {
248 	long rc;
249 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
250 
251 	rc = plpar_hcall(H_GET_TCE, retbuf, liobn, ioba);
252 
253 	*tce_ret = retbuf[0];
254 
255 	return rc;
256 }
257 
258 static inline long plpar_tce_put(unsigned long liobn, unsigned long ioba,
259 		unsigned long tceval)
260 {
261 	return plpar_hcall_norets(H_PUT_TCE, liobn, ioba, tceval);
262 }
263 
264 static inline long plpar_tce_put_indirect(unsigned long liobn,
265 		unsigned long ioba, unsigned long page, unsigned long count)
266 {
267 	return plpar_hcall_norets(H_PUT_TCE_INDIRECT, liobn, ioba, page, count);
268 }
269 
270 static inline long plpar_tce_stuff(unsigned long liobn, unsigned long ioba,
271 		unsigned long tceval, unsigned long count)
272 {
273 	return plpar_hcall_norets(H_STUFF_TCE, liobn, ioba, tceval, count);
274 }
275 
276 /* Set various resource mode parameters */
277 static inline long plpar_set_mode(unsigned long mflags, unsigned long resource,
278 		unsigned long value1, unsigned long value2)
279 {
280 	return plpar_hcall_norets(H_SET_MODE, mflags, resource, value1, value2);
281 }
282 
283 /*
284  * Enable relocation on exceptions on this partition
285  *
286  * Note: this call has a partition wide scope and can take a while to complete.
287  * If it returns H_LONG_BUSY_* it should be retried periodically until it
288  * returns H_SUCCESS.
289  */
290 static inline long enable_reloc_on_exceptions(void)
291 {
292 	/* mflags = 3: Exceptions at 0xC000000000004000 */
293 	return plpar_set_mode(3, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0);
294 }
295 
296 /*
297  * Disable relocation on exceptions on this partition
298  *
299  * Note: this call has a partition wide scope and can take a while to complete.
300  * If it returns H_LONG_BUSY_* it should be retried periodically until it
301  * returns H_SUCCESS.
302  */
303 static inline long disable_reloc_on_exceptions(void) {
304 	return plpar_set_mode(0, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0);
305 }
306 
307 /*
308  * Take exceptions in big endian mode on this partition
309  *
310  * Note: this call has a partition wide scope and can take a while to complete.
311  * If it returns H_LONG_BUSY_* it should be retried periodically until it
312  * returns H_SUCCESS.
313  */
314 static inline long enable_big_endian_exceptions(void)
315 {
316 	/* mflags = 0: big endian exceptions */
317 	return plpar_set_mode(0, H_SET_MODE_RESOURCE_LE, 0, 0);
318 }
319 
320 /*
321  * Take exceptions in little endian mode on this partition
322  *
323  * Note: this call has a partition wide scope and can take a while to complete.
324  * If it returns H_LONG_BUSY_* it should be retried periodically until it
325  * returns H_SUCCESS.
326  */
327 static inline long enable_little_endian_exceptions(void)
328 {
329 	/* mflags = 1: little endian exceptions */
330 	return plpar_set_mode(1, H_SET_MODE_RESOURCE_LE, 0, 0);
331 }
332 
333 static inline long plapr_set_ciabr(unsigned long ciabr)
334 {
335 	return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_CIABR, ciabr, 0);
336 }
337 
338 static inline long plapr_set_watchpoint0(unsigned long dawr0, unsigned long dawrx0)
339 {
340 	return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_DAWR, dawr0, dawrx0);
341 }
342 
343 #endif /* _ASM_POWERPC_PLPAR_WRAPPERS_H */
344