1 #ifndef _ASM_POWERPC_HEAD_64_H 2 #define _ASM_POWERPC_HEAD_64_H 3 4 #include <asm/cache.h> 5 6 /* 7 * We can't do CPP stringification and concatination directly into the section 8 * name for some reason, so these macros can do it for us. 9 */ 10 .macro define_ftsec name 11 .section ".head.text.\name\()","ax",@progbits 12 .endm 13 .macro define_data_ftsec name 14 .section ".head.data.\name\()","a",@progbits 15 .endm 16 .macro use_ftsec name 17 .section ".head.text.\name\()" 18 .endm 19 20 /* 21 * Fixed (location) sections are used by opening fixed sections and emitting 22 * fixed section entries into them before closing them. Multiple fixed sections 23 * can be open at any time. 24 * 25 * Each fixed section created in a .S file must have corresponding linkage 26 * directives including location, added to arch/powerpc/kernel/vmlinux.lds.S 27 * 28 * For each fixed section, code is generated into it in the order which it 29 * appears in the source. Fixed section entries can be placed at a fixed 30 * location within the section using _LOCATION postifx variants. These must 31 * be ordered according to their relative placements within the section. 32 * 33 * OPEN_FIXED_SECTION(section_name, start_address, end_address) 34 * FIXED_SECTION_ENTRY_BEGIN(section_name, label1) 35 * 36 * USE_FIXED_SECTION(section_name) 37 * label3: 38 * li r10,128 39 * mv r11,r10 40 41 * FIXED_SECTION_ENTRY_BEGIN_LOCATION(section_name, label2, start_address, size) 42 * FIXED_SECTION_ENTRY_END_LOCATION(section_name, label2, start_address, size) 43 * CLOSE_FIXED_SECTION(section_name) 44 * 45 * ZERO_FIXED_SECTION can be used to emit zeroed data. 46 * 47 * Troubleshooting: 48 * - If the build dies with "Error: attempt to move .org backwards" at 49 * CLOSE_FIXED_SECTION() or elsewhere, there may be something 50 * unexpected being added there. Remove the '. = x_len' line, rebuild, and 51 * check what is pushing the section down. 52 * - If the build dies in linking, check arch/powerpc/kernel/vmlinux.lds.S 53 * for instructions. 54 * - If the kernel crashes or hangs in very early boot, it could be linker 55 * stubs at the start of the main text. 56 */ 57 58 #define OPEN_FIXED_SECTION(sname, start, end) \ 59 sname##_start = (start); \ 60 sname##_end = (end); \ 61 sname##_len = (end) - (start); \ 62 define_ftsec sname; \ 63 . = 0x0; \ 64 start_##sname: 65 66 #define OPEN_TEXT_SECTION(start) \ 67 text_start = (start); \ 68 .section ".text","ax",@progbits; \ 69 . = 0x0; \ 70 start_text: 71 72 #define ZERO_FIXED_SECTION(sname, start, end) \ 73 sname##_start = (start); \ 74 sname##_end = (end); \ 75 sname##_len = (end) - (start); \ 76 define_data_ftsec sname; \ 77 . = 0x0; \ 78 . = sname##_len; 79 80 #define USE_FIXED_SECTION(sname) \ 81 fs_label = start_##sname; \ 82 fs_start = sname##_start; \ 83 use_ftsec sname; 84 85 #define USE_TEXT_SECTION() \ 86 fs_label = start_text; \ 87 fs_start = text_start; \ 88 .text 89 90 #define CLOSE_FIXED_SECTION(sname) \ 91 USE_FIXED_SECTION(sname); \ 92 . = sname##_len; \ 93 end_##sname: 94 95 96 #define __FIXED_SECTION_ENTRY_BEGIN(sname, name, __align) \ 97 USE_FIXED_SECTION(sname); \ 98 .balign __align; \ 99 .global name; \ 100 name: 101 102 #define FIXED_SECTION_ENTRY_BEGIN(sname, name) \ 103 __FIXED_SECTION_ENTRY_BEGIN(sname, name, IFETCH_ALIGN_BYTES) 104 105 #define FIXED_SECTION_ENTRY_BEGIN_LOCATION(sname, name, start, size) \ 106 USE_FIXED_SECTION(sname); \ 107 name##_start = (start); \ 108 .if ((start) % (size) != 0); \ 109 .error "Fixed section exception vector misalignment"; \ 110 .endif; \ 111 .if ((size) != 0x20) && ((size) != 0x80) && ((size) != 0x100); \ 112 .error "Fixed section exception vector bad size"; \ 113 .endif; \ 114 .if (start) < sname##_start; \ 115 .error "Fixed section underflow"; \ 116 .abort; \ 117 .endif; \ 118 . = (start) - sname##_start; \ 119 .global name; \ 120 name: 121 122 #define FIXED_SECTION_ENTRY_END_LOCATION(sname, name, start, size) \ 123 .if (start) + (size) > sname##_end; \ 124 .error "Fixed section overflow"; \ 125 .abort; \ 126 .endif; \ 127 .if (. - name > (start) + (size) - name##_start); \ 128 .error "Fixed entry overflow"; \ 129 .abort; \ 130 .endif; \ 131 . = ((start) + (size) - sname##_start); \ 132 133 134 /* 135 * These macros are used to change symbols in other fixed sections to be 136 * absolute or related to our current fixed section. 137 * 138 * - DEFINE_FIXED_SYMBOL / FIXED_SYMBOL_ABS_ADDR is used to find the 139 * absolute address of a symbol within a fixed section, from any section. 140 * 141 * - ABS_ADDR is used to find the absolute address of any symbol, from within 142 * a fixed section. 143 */ 144 #define DEFINE_FIXED_SYMBOL(label) \ 145 label##_absolute = (label - fs_label + fs_start) 146 147 #define FIXED_SYMBOL_ABS_ADDR(label) \ 148 (label##_absolute) 149 150 #define ABS_ADDR(label) (label - fs_label + fs_start) 151 152 /* 153 * Following are the BOOK3S exception handler helper macros. 154 * Handlers come in a number of types, and each type has a number of varieties. 155 * 156 * EXC_REAL_* - real, unrelocated exception vectors 157 * EXC_VIRT_* - virt (AIL), unrelocated exception vectors 158 * TRAMP_REAL_* - real, unrelocated helpers (virt can call these) 159 * TRAMP_VIRT_* - virt, unreloc helpers (in practice, real can use) 160 * TRAMP_KVM - KVM handlers that get put into real, unrelocated 161 * EXC_COMMON_* - virt, relocated common handlers 162 * 163 * The EXC handlers are given a name, and branch to name_common, or the 164 * appropriate KVM or masking function. Vector handler verieties are as 165 * follows: 166 * 167 * EXC_{REAL|VIRT}_BEGIN/END - used to open-code the exception 168 * 169 * EXC_{REAL|VIRT} - standard exception 170 * 171 * EXC_{REAL|VIRT}_suffix 172 * where _suffix is: 173 * - _MASKABLE - maskable exception 174 * - _OOL - out of line with trampoline to common handler 175 * - _HV - HV exception 176 * 177 * There can be combinations, e.g., EXC_VIRT_OOL_MASKABLE_HV 178 * 179 * The one unusual case is __EXC_REAL_OOL_HV_DIRECT, which is 180 * an OOL vector that branches to a specified handler rather than the usual 181 * trampoline that goes to common. It, and other underscore macros, should 182 * be used with care. 183 * 184 * KVM handlers come in the following verieties: 185 * TRAMP_KVM 186 * TRAMP_KVM_SKIP 187 * TRAMP_KVM_HV 188 * TRAMP_KVM_HV_SKIP 189 * 190 * COMMON handlers come in the following verieties: 191 * EXC_COMMON_BEGIN/END - used to open-code the handler 192 * EXC_COMMON 193 * EXC_COMMON_ASYNC 194 * EXC_COMMON_HV 195 * 196 * TRAMP_REAL and TRAMP_VIRT can be used with BEGIN/END. KVM 197 * and OOL handlers are implemented as types of TRAMP and TRAMP_VIRT handlers. 198 */ 199 200 #define EXC_REAL_BEGIN(name, start, size) \ 201 FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##name, start, size) 202 203 #define EXC_REAL_END(name, start, size) \ 204 FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##name, start, size) 205 206 #define EXC_VIRT_BEGIN(name, start, size) \ 207 FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size) 208 209 #define EXC_VIRT_END(name, start, size) \ 210 FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size) 211 212 #define EXC_COMMON_BEGIN(name) \ 213 USE_TEXT_SECTION(); \ 214 .balign IFETCH_ALIGN_BYTES; \ 215 .global name; \ 216 _ASM_NOKPROBE_SYMBOL(name); \ 217 DEFINE_FIXED_SYMBOL(name); \ 218 name: 219 220 #define TRAMP_REAL_BEGIN(name) \ 221 FIXED_SECTION_ENTRY_BEGIN(real_trampolines, name) 222 223 #define TRAMP_VIRT_BEGIN(name) \ 224 FIXED_SECTION_ENTRY_BEGIN(virt_trampolines, name) 225 226 #ifdef CONFIG_KVM_BOOK3S_64_HANDLER 227 #define TRAMP_KVM_BEGIN(name) \ 228 TRAMP_VIRT_BEGIN(name) 229 #else 230 #define TRAMP_KVM_BEGIN(name) 231 #endif 232 233 #define EXC_REAL_NONE(start, size) \ 234 FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##unused, start, size); \ 235 FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##unused, start, size) 236 237 #define EXC_VIRT_NONE(start, size) \ 238 FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \ 239 FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); 240 241 242 #define EXC_REAL(name, start, size) \ 243 EXC_REAL_BEGIN(name, start, size); \ 244 STD_EXCEPTION_PSERIES(start, name##_common); \ 245 EXC_REAL_END(name, start, size); 246 247 #define EXC_VIRT(name, start, size, realvec) \ 248 EXC_VIRT_BEGIN(name, start, size); \ 249 STD_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \ 250 EXC_VIRT_END(name, start, size); 251 252 #define EXC_REAL_MASKABLE(name, start, size) \ 253 EXC_REAL_BEGIN(name, start, size); \ 254 MASKABLE_EXCEPTION_PSERIES(start, start, name##_common); \ 255 EXC_REAL_END(name, start, size); 256 257 #define EXC_VIRT_MASKABLE(name, start, size, realvec) \ 258 EXC_VIRT_BEGIN(name, start, size); \ 259 MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \ 260 EXC_VIRT_END(name, start, size); 261 262 #define EXC_REAL_HV(name, start, size) \ 263 EXC_REAL_BEGIN(name, start, size); \ 264 STD_EXCEPTION_HV(start, start, name##_common); \ 265 EXC_REAL_END(name, start, size); 266 267 #define EXC_VIRT_HV(name, start, size, realvec) \ 268 EXC_VIRT_BEGIN(name, start, size); \ 269 STD_RELON_EXCEPTION_HV(start, realvec, name##_common); \ 270 EXC_VIRT_END(name, start, size); 271 272 #define __EXC_REAL_OOL(name, start, size) \ 273 EXC_REAL_BEGIN(name, start, size); \ 274 __OOL_EXCEPTION(start, label, tramp_real_##name); \ 275 EXC_REAL_END(name, start, size); 276 277 #define __TRAMP_REAL_OOL(name, vec) \ 278 TRAMP_REAL_BEGIN(tramp_real_##name); \ 279 STD_EXCEPTION_PSERIES_OOL(vec, name##_common); \ 280 281 #define EXC_REAL_OOL(name, start, size) \ 282 __EXC_REAL_OOL(name, start, size); \ 283 __TRAMP_REAL_OOL(name, start); 284 285 #define __EXC_REAL_OOL_MASKABLE(name, start, size) \ 286 __EXC_REAL_OOL(name, start, size); 287 288 #define __TRAMP_REAL_OOL_MASKABLE(name, vec) \ 289 TRAMP_REAL_BEGIN(tramp_real_##name); \ 290 MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common); \ 291 292 #define EXC_REAL_OOL_MASKABLE(name, start, size) \ 293 __EXC_REAL_OOL_MASKABLE(name, start, size); \ 294 __TRAMP_REAL_OOL_MASKABLE(name, start); 295 296 #define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler) \ 297 EXC_REAL_BEGIN(name, start, size); \ 298 __OOL_EXCEPTION(start, label, handler); \ 299 EXC_REAL_END(name, start, size); 300 301 #define __EXC_REAL_OOL_HV(name, start, size) \ 302 __EXC_REAL_OOL(name, start, size); 303 304 #define __TRAMP_REAL_OOL_HV(name, vec) \ 305 TRAMP_REAL_BEGIN(tramp_real_##name); \ 306 STD_EXCEPTION_HV_OOL(vec, name##_common); \ 307 308 #define EXC_REAL_OOL_HV(name, start, size) \ 309 __EXC_REAL_OOL_HV(name, start, size); \ 310 __TRAMP_REAL_OOL_HV(name, start); 311 312 #define __EXC_REAL_OOL_MASKABLE_HV(name, start, size) \ 313 __EXC_REAL_OOL(name, start, size); 314 315 #define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec) \ 316 TRAMP_REAL_BEGIN(tramp_real_##name); \ 317 MASKABLE_EXCEPTION_HV_OOL(vec, name##_common); \ 318 319 #define EXC_REAL_OOL_MASKABLE_HV(name, start, size) \ 320 __EXC_REAL_OOL_MASKABLE_HV(name, start, size); \ 321 __TRAMP_REAL_OOL_MASKABLE_HV(name, start); 322 323 #define __EXC_VIRT_OOL(name, start, size) \ 324 EXC_VIRT_BEGIN(name, start, size); \ 325 __OOL_EXCEPTION(start, label, tramp_virt_##name); \ 326 EXC_VIRT_END(name, start, size); 327 328 #define __TRAMP_VIRT_OOL(name, realvec) \ 329 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 330 STD_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \ 331 332 #define EXC_VIRT_OOL(name, start, size, realvec) \ 333 __EXC_VIRT_OOL(name, start, size); \ 334 __TRAMP_VIRT_OOL(name, realvec); 335 336 #define __EXC_VIRT_OOL_MASKABLE(name, start, size) \ 337 __EXC_VIRT_OOL(name, start, size); 338 339 #define __TRAMP_VIRT_OOL_MASKABLE(name, realvec) \ 340 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 341 MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \ 342 343 #define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec) \ 344 __EXC_VIRT_OOL_MASKABLE(name, start, size); \ 345 __TRAMP_VIRT_OOL_MASKABLE(name, realvec); 346 347 #define __EXC_VIRT_OOL_HV(name, start, size) \ 348 __EXC_VIRT_OOL(name, start, size); 349 350 #define __TRAMP_VIRT_OOL_HV(name, realvec) \ 351 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 352 STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \ 353 354 #define EXC_VIRT_OOL_HV(name, start, size, realvec) \ 355 __EXC_VIRT_OOL_HV(name, start, size); \ 356 __TRAMP_VIRT_OOL_HV(name, realvec); 357 358 #define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size) \ 359 __EXC_VIRT_OOL(name, start, size); 360 361 #define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec) \ 362 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 363 MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \ 364 365 #define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec) \ 366 __EXC_VIRT_OOL_MASKABLE_HV(name, start, size); \ 367 __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec); 368 369 #define TRAMP_KVM(area, n) \ 370 TRAMP_KVM_BEGIN(do_kvm_##n); \ 371 KVM_HANDLER(area, EXC_STD, n); \ 372 373 #define TRAMP_KVM_SKIP(area, n) \ 374 TRAMP_KVM_BEGIN(do_kvm_##n); \ 375 KVM_HANDLER_SKIP(area, EXC_STD, n); \ 376 377 /* 378 * HV variant exceptions get the 0x2 bit added to their trap number. 379 */ 380 #define TRAMP_KVM_HV(area, n) \ 381 TRAMP_KVM_BEGIN(do_kvm_H##n); \ 382 KVM_HANDLER(area, EXC_HV, n + 0x2); \ 383 384 #define TRAMP_KVM_HV_SKIP(area, n) \ 385 TRAMP_KVM_BEGIN(do_kvm_H##n); \ 386 KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2); \ 387 388 #define EXC_COMMON(name, realvec, hdlr) \ 389 EXC_COMMON_BEGIN(name); \ 390 STD_EXCEPTION_COMMON(realvec, name, hdlr); \ 391 392 #define EXC_COMMON_ASYNC(name, realvec, hdlr) \ 393 EXC_COMMON_BEGIN(name); \ 394 STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr); \ 395 396 #define EXC_COMMON_HV(name, realvec, hdlr) \ 397 EXC_COMMON_BEGIN(name); \ 398 STD_EXCEPTION_COMMON(realvec + 0x2, name, hdlr); \ 399 400 #endif /* _ASM_POWERPC_HEAD_64_H */ 401