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 * plpar_pte_read_4_raw can be called in real mode. 206 * ptes must be 8*sizeof(unsigned long) 207 */ 208 static 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 222 static 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 228 static 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 241 static 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 247 static 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 253 static 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 */ 260 static 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 */ 273 static 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 */ 286 static 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 */ 297 static 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 */ 310 static 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 316 static 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 321 static 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