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 */ 12int 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 19static inline long poll_pending(void) 20{ 21 return plpar_hcall_norets(H_POLL_PENDING); 22} 23 24static inline u8 get_cede_latency_hint(void) 25{ 26 return get_lppaca()->cede_latency_hint; 27} 28 29static inline void set_cede_latency_hint(u8 latency_hint) 30{ 31 get_lppaca()->cede_latency_hint = latency_hint; 32} 33 34static inline long cede_processor(void) 35{ 36 return plpar_hcall_norets(H_CEDE); 37} 38 39static 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 58static 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 66static inline long unregister_vpa(unsigned long cpu) 67{ 68 return vpa_call(H_VPA_DEREG_VPA, cpu, 0); 69} 70 71static inline long register_vpa(unsigned long cpu, unsigned long vpa) 72{ 73 return vpa_call(H_VPA_REG_VPA, cpu, vpa); 74} 75 76static inline long unregister_slb_shadow(unsigned long cpu) 77{ 78 return vpa_call(H_VPA_DEREG_SLB, cpu, 0); 79} 80 81static inline long register_slb_shadow(unsigned long cpu, unsigned long vpa) 82{ 83 return vpa_call(H_VPA_REG_SLB, cpu, vpa); 84} 85 86static inline long unregister_dtl(unsigned long cpu) 87{ 88 return vpa_call(H_VPA_DEREG_DTL, cpu, 0); 89} 90 91static inline long register_dtl(unsigned long cpu, unsigned long vpa) 92{ 93 return vpa_call(H_VPA_REG_DTL, cpu, vpa); 94} 95 96static 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 112static 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 128extern void vpa_init(int cpu); 129 130static 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 144static 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 */ 160static 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 175static 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 */ 190static 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 * plpar_pte_read_4_raw can be called in real mode. 206 * ptes must be 8*sizeof(unsigned long) 207 */ 208static inline long plpar_pte_read_4_raw(unsigned long flags, unsigned long ptex, 209 unsigned long *ptes) 210 211{ 212 long rc; 213 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; 214 215 rc = plpar_hcall9_raw(H_READ, retbuf, flags | H_READ_4, ptex); 216 217 memcpy(ptes, retbuf, 8*sizeof(unsigned long)); 218 219 return rc; 220} 221 222static inline long plpar_pte_protect(unsigned long flags, unsigned long ptex, 223 unsigned long avpn) 224{ 225 return plpar_hcall_norets(H_PROTECT, flags, ptex, avpn); 226} 227 228static inline long plpar_tce_get(unsigned long liobn, unsigned long ioba, 229 unsigned long *tce_ret) 230{ 231 long rc; 232 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 233 234 rc = plpar_hcall(H_GET_TCE, retbuf, liobn, ioba); 235 236 *tce_ret = retbuf[0]; 237 238 return rc; 239} 240 241static inline long plpar_tce_put(unsigned long liobn, unsigned long ioba, 242 unsigned long tceval) 243{ 244 return plpar_hcall_norets(H_PUT_TCE, liobn, ioba, tceval); 245} 246 247static inline long plpar_tce_put_indirect(unsigned long liobn, 248 unsigned long ioba, unsigned long page, unsigned long count) 249{ 250 return plpar_hcall_norets(H_PUT_TCE_INDIRECT, liobn, ioba, page, count); 251} 252 253static inline long plpar_tce_stuff(unsigned long liobn, unsigned long ioba, 254 unsigned long tceval, unsigned long count) 255{ 256 return plpar_hcall_norets(H_STUFF_TCE, liobn, ioba, tceval, count); 257} 258 259/* Set various resource mode parameters */ 260static inline long plpar_set_mode(unsigned long mflags, unsigned long resource, 261 unsigned long value1, unsigned long value2) 262{ 263 return plpar_hcall_norets(H_SET_MODE, mflags, resource, value1, value2); 264} 265 266/* 267 * Enable relocation on exceptions on this partition 268 * 269 * Note: this call has a partition wide scope and can take a while to complete. 270 * If it returns H_LONG_BUSY_* it should be retried periodically until it 271 * returns H_SUCCESS. 272 */ 273static inline long enable_reloc_on_exceptions(void) 274{ 275 /* mflags = 3: Exceptions at 0xC000000000004000 */ 276 return plpar_set_mode(3, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0); 277} 278 279/* 280 * Disable relocation on exceptions on this partition 281 * 282 * Note: this call has a partition wide scope and can take a while to complete. 283 * If it returns H_LONG_BUSY_* it should be retried periodically until it 284 * returns H_SUCCESS. 285 */ 286static inline long disable_reloc_on_exceptions(void) { 287 return plpar_set_mode(0, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0); 288} 289 290/* 291 * Take exceptions in big endian mode on this partition 292 * 293 * Note: this call has a partition wide scope and can take a while to complete. 294 * If it returns H_LONG_BUSY_* it should be retried periodically until it 295 * returns H_SUCCESS. 296 */ 297static inline long enable_big_endian_exceptions(void) 298{ 299 /* mflags = 0: big endian exceptions */ 300 return plpar_set_mode(0, H_SET_MODE_RESOURCE_LE, 0, 0); 301} 302 303/* 304 * Take exceptions in little endian mode on this partition 305 * 306 * Note: this call has a partition wide scope and can take a while to complete. 307 * If it returns H_LONG_BUSY_* it should be retried periodically until it 308 * returns H_SUCCESS. 309 */ 310static inline long enable_little_endian_exceptions(void) 311{ 312 /* mflags = 1: little endian exceptions */ 313 return plpar_set_mode(1, H_SET_MODE_RESOURCE_LE, 0, 0); 314} 315 316static inline long plapr_set_ciabr(unsigned long ciabr) 317{ 318 return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_CIABR, ciabr, 0); 319} 320 321static inline long plapr_set_watchpoint0(unsigned long dawr0, unsigned long dawrx0) 322{ 323 return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_DAWR, dawr0, dawrx0); 324} 325 326#endif /* _ASM_POWERPC_PLPAR_WRAPPERS_H */ 327