1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * Assembly code support for the Olympus-C module 26 */ 27 28 #if !defined(lint) 29 #include "assym.h" 30 #endif /* lint */ 31 32 #include <sys/asm_linkage.h> 33 #include <sys/mmu.h> 34 #include <vm/hat_sfmmu.h> 35 #include <sys/machparam.h> 36 #include <sys/machcpuvar.h> 37 #include <sys/machthread.h> 38 #include <sys/machtrap.h> 39 #include <sys/privregs.h> 40 #include <sys/asm_linkage.h> 41 #include <sys/trap.h> 42 #include <sys/opl_olympus_regs.h> 43 #include <sys/opl_module.h> 44 #include <sys/xc_impl.h> 45 #include <sys/intreg.h> 46 #include <sys/async.h> 47 #include <sys/clock.h> 48 #include <sys/cmpregs.h> 49 50 #ifdef TRAPTRACE 51 #include <sys/traptrace.h> 52 #endif /* TRAPTRACE */ 53 54 /* 55 * Macro that flushes the entire Ecache. 56 * 57 * arg1 = ecache size 58 * arg2 = ecache linesize 59 * arg3 = ecache flush address - Not used for olympus-C 60 */ 61 #define ECACHE_FLUSHALL(arg1, arg2, arg3, tmp1) \ 62 mov ASI_L2_CTRL_U2_FLUSH, arg1; \ 63 mov ASI_L2_CTRL_RW_ADDR, arg2; \ 64 stxa arg1, [arg2]ASI_L2_CTRL 65 66 /* 67 * SPARC64-VI MMU and Cache operations. 68 */ 69 70 #if defined(lint) 71 72 /* ARGSUSED */ 73 void 74 vtag_flushpage(caddr_t vaddr, uint64_t sfmmup) 75 {} 76 77 #else /* lint */ 78 79 ENTRY_NP(vtag_flushpage) 80 /* 81 * flush page from the tlb 82 * 83 * %o0 = vaddr 84 * %o1 = sfmmup 85 */ 86 rdpr %pstate, %o5 87 #ifdef DEBUG 88 PANIC_IF_INTR_DISABLED_PSTR(%o5, opl_di_l3, %g1) 89 #endif /* DEBUG */ 90 /* 91 * disable ints 92 */ 93 andn %o5, PSTATE_IE, %o4 94 wrpr %o4, 0, %pstate 95 96 /* 97 * Then, blow out the tlb 98 * Interrupts are disabled to prevent the primary ctx register 99 * from changing underneath us. 100 */ 101 sethi %hi(ksfmmup), %o3 102 ldx [%o3 + %lo(ksfmmup)], %o3 103 cmp %o3, %o1 104 bne,pt %xcc, 1f ! if not kernel as, go to 1 105 sethi %hi(FLUSH_ADDR), %o3 106 /* 107 * For Kernel demaps use primary. type = page implicitly 108 */ 109 stxa %g0, [%o0]ASI_DTLB_DEMAP /* dmmu flush for KCONTEXT */ 110 stxa %g0, [%o0]ASI_ITLB_DEMAP /* immu flush for KCONTEXT */ 111 flush %o3 112 retl 113 wrpr %g0, %o5, %pstate /* enable interrupts */ 114 1: 115 /* 116 * User demap. We need to set the primary context properly. 117 * Secondary context cannot be used for SPARC64-VI IMMU. 118 * %o0 = vaddr 119 * %o1 = sfmmup 120 * %o3 = FLUSH_ADDR 121 */ 122 SFMMU_CPU_CNUM(%o1, %g1, %g2) ! %g1 = sfmmu cnum on this CPU 123 124 ldub [%o1 + SFMMU_CEXT], %o4 ! %o4 = sfmmup->sfmmu_cext 125 sll %o4, CTXREG_EXT_SHIFT, %o4 126 or %g1, %o4, %g1 ! %g1 = primary pgsz | cnum 127 128 wrpr %g0, 1, %tl 129 set MMU_PCONTEXT, %o4 130 or DEMAP_PRIMARY | DEMAP_PAGE_TYPE, %o0, %o0 131 ldxa [%o4]ASI_DMMU, %o2 ! %o2 = save old ctxnum 132 srlx %o2, CTXREG_NEXT_SHIFT, %o1 ! need to preserve nucleus pgsz 133 sllx %o1, CTXREG_NEXT_SHIFT, %o1 ! %o1 = nucleus pgsz 134 or %g1, %o1, %g1 ! %g1 = nucleus pgsz | primary pgsz | cnum 135 stxa %g1, [%o4]ASI_DMMU ! wr new ctxum 136 137 stxa %g0, [%o0]ASI_DTLB_DEMAP 138 stxa %g0, [%o0]ASI_ITLB_DEMAP 139 stxa %o2, [%o4]ASI_DMMU /* restore old ctxnum */ 140 flush %o3 141 wrpr %g0, 0, %tl 142 143 retl 144 wrpr %g0, %o5, %pstate /* enable interrupts */ 145 SET_SIZE(vtag_flushpage) 146 147 #endif /* lint */ 148 149 150 #if defined(lint) 151 152 void 153 vtag_flushall(void) 154 {} 155 156 #else /* lint */ 157 158 ENTRY_NP2(vtag_flushall, demap_all) 159 /* 160 * flush the tlb 161 */ 162 sethi %hi(FLUSH_ADDR), %o3 163 set DEMAP_ALL_TYPE, %g1 164 stxa %g0, [%g1]ASI_DTLB_DEMAP 165 stxa %g0, [%g1]ASI_ITLB_DEMAP 166 flush %o3 167 retl 168 nop 169 SET_SIZE(demap_all) 170 SET_SIZE(vtag_flushall) 171 172 #endif /* lint */ 173 174 175 #if defined(lint) 176 177 /* ARGSUSED */ 178 void 179 vtag_flushpage_tl1(uint64_t vaddr, uint64_t sfmmup) 180 {} 181 182 #else /* lint */ 183 184 ENTRY_NP(vtag_flushpage_tl1) 185 /* 186 * x-trap to flush page from tlb and tsb 187 * 188 * %g1 = vaddr, zero-extended on 32-bit kernel 189 * %g2 = sfmmup 190 * 191 * assumes TSBE_TAG = 0 192 */ 193 srln %g1, MMU_PAGESHIFT, %g1 194 195 sethi %hi(ksfmmup), %g3 196 ldx [%g3 + %lo(ksfmmup)], %g3 197 cmp %g3, %g2 198 bne,pt %xcc, 1f ! if not kernel as, go to 1 199 slln %g1, MMU_PAGESHIFT, %g1 /* g1 = vaddr */ 200 201 /* We need to demap in the kernel context */ 202 or DEMAP_NUCLEUS | DEMAP_PAGE_TYPE, %g1, %g1 203 stxa %g0, [%g1]ASI_DTLB_DEMAP 204 stxa %g0, [%g1]ASI_ITLB_DEMAP 205 retry 206 1: 207 /* We need to demap in a user context */ 208 or DEMAP_PRIMARY | DEMAP_PAGE_TYPE, %g1, %g1 209 210 SFMMU_CPU_CNUM(%g2, %g6, %g3) ! %g6 = sfmmu cnum on this CPU 211 212 ldub [%g2 + SFMMU_CEXT], %g4 ! %g4 = sfmmup->cext 213 sll %g4, CTXREG_EXT_SHIFT, %g4 214 or %g6, %g4, %g6 ! %g6 = primary pgsz | cnum 215 216 set MMU_PCONTEXT, %g4 217 ldxa [%g4]ASI_DMMU, %g5 ! %g5 = save old ctxnum 218 srlx %g5, CTXREG_NEXT_SHIFT, %g2 ! %g2 = nucleus pgsz 219 sllx %g2, CTXREG_NEXT_SHIFT, %g2 ! preserve nucleus pgsz 220 or %g6, %g2, %g6 ! %g6 = nucleus pgsz | primary pgsz | cnum 221 stxa %g6, [%g4]ASI_DMMU ! wr new ctxum 222 stxa %g0, [%g1]ASI_DTLB_DEMAP 223 stxa %g0, [%g1]ASI_ITLB_DEMAP 224 stxa %g5, [%g4]ASI_DMMU ! restore old ctxnum 225 retry 226 SET_SIZE(vtag_flushpage_tl1) 227 228 #endif /* lint */ 229 230 231 #if defined(lint) 232 233 /* ARGSUSED */ 234 void 235 vtag_flush_pgcnt_tl1(uint64_t vaddr, uint64_t sfmmup_pgcnt) 236 {} 237 238 #else /* lint */ 239 240 ENTRY_NP(vtag_flush_pgcnt_tl1) 241 /* 242 * x-trap to flush pgcnt MMU_PAGESIZE pages from tlb 243 * 244 * %g1 = vaddr, zero-extended on 32-bit kernel 245 * %g2 = <sfmmup58|pgcnt6> 246 * 247 * NOTE: this handler relies on the fact that no 248 * interrupts or traps can occur during the loop 249 * issuing the TLB_DEMAP operations. It is assumed 250 * that interrupts are disabled and this code is 251 * fetching from the kernel locked text address. 252 * 253 * assumes TSBE_TAG = 0 254 */ 255 set SFMMU_PGCNT_MASK, %g4 256 and %g4, %g2, %g3 /* g3 = pgcnt - 1 */ 257 add %g3, 1, %g3 /* g3 = pgcnt */ 258 259 andn %g2, SFMMU_PGCNT_MASK, %g2 /* g2 = sfmmup */ 260 srln %g1, MMU_PAGESHIFT, %g1 261 262 sethi %hi(ksfmmup), %g4 263 ldx [%g4 + %lo(ksfmmup)], %g4 264 cmp %g4, %g2 265 bne,pn %xcc, 1f /* if not kernel as, go to 1 */ 266 slln %g1, MMU_PAGESHIFT, %g1 /* g1 = vaddr */ 267 268 /* We need to demap in the kernel context */ 269 or DEMAP_NUCLEUS | DEMAP_PAGE_TYPE, %g1, %g1 270 set MMU_PAGESIZE, %g2 /* g2 = pgsize */ 271 sethi %hi(FLUSH_ADDR), %g5 272 4: 273 stxa %g0, [%g1]ASI_DTLB_DEMAP 274 stxa %g0, [%g1]ASI_ITLB_DEMAP 275 flush %g5 ! flush required by immu 276 277 deccc %g3 /* decr pgcnt */ 278 bnz,pt %icc,4b 279 add %g1, %g2, %g1 /* next page */ 280 retry 281 1: 282 /* 283 * We need to demap in a user context 284 * 285 * g2 = sfmmup 286 * g3 = pgcnt 287 */ 288 SFMMU_CPU_CNUM(%g2, %g5, %g6) ! %g5 = sfmmu cnum on this CPU 289 290 or DEMAP_PRIMARY | DEMAP_PAGE_TYPE, %g1, %g1 291 292 ldub [%g2 + SFMMU_CEXT], %g4 ! %g4 = sfmmup->cext 293 sll %g4, CTXREG_EXT_SHIFT, %g4 294 or %g5, %g4, %g5 295 296 set MMU_PCONTEXT, %g4 297 ldxa [%g4]ASI_DMMU, %g6 /* rd old ctxnum */ 298 srlx %g6, CTXREG_NEXT_SHIFT, %g2 /* %g2 = nucleus pgsz */ 299 sllx %g2, CTXREG_NEXT_SHIFT, %g2 /* preserve nucleus pgsz */ 300 or %g5, %g2, %g5 /* %g5 = nucleus pgsz | primary pgsz | cnum */ 301 stxa %g5, [%g4]ASI_DMMU /* wr new ctxum */ 302 303 set MMU_PAGESIZE, %g2 /* g2 = pgsize */ 304 sethi %hi(FLUSH_ADDR), %g5 305 3: 306 stxa %g0, [%g1]ASI_DTLB_DEMAP 307 stxa %g0, [%g1]ASI_ITLB_DEMAP 308 flush %g5 ! flush required by immu 309 310 deccc %g3 /* decr pgcnt */ 311 bnz,pt %icc,3b 312 add %g1, %g2, %g1 /* next page */ 313 314 stxa %g6, [%g4]ASI_DMMU /* restore old ctxnum */ 315 retry 316 SET_SIZE(vtag_flush_pgcnt_tl1) 317 318 #endif /* lint */ 319 320 321 #if defined(lint) 322 323 /*ARGSUSED*/ 324 void 325 vtag_flushall_tl1(uint64_t dummy1, uint64_t dummy2) 326 {} 327 328 #else /* lint */ 329 330 ENTRY_NP(vtag_flushall_tl1) 331 /* 332 * x-trap to flush tlb 333 */ 334 set DEMAP_ALL_TYPE, %g4 335 stxa %g0, [%g4]ASI_DTLB_DEMAP 336 stxa %g0, [%g4]ASI_ITLB_DEMAP 337 retry 338 SET_SIZE(vtag_flushall_tl1) 339 340 #endif /* lint */ 341 342 343 /* 344 * VAC (virtual address conflict) does not apply to OPL. 345 * VAC resolution is managed by the Olympus processor hardware. 346 * As a result, all OPL VAC flushing routines are no-ops. 347 */ 348 349 #if defined(lint) 350 351 /* ARGSUSED */ 352 void 353 vac_flushpage(pfn_t pfnum, int vcolor) 354 {} 355 356 #else /* lint */ 357 358 ENTRY(vac_flushpage) 359 retl 360 nop 361 SET_SIZE(vac_flushpage) 362 363 #endif /* lint */ 364 365 #if defined(lint) 366 367 /* ARGSUSED */ 368 void 369 vac_flushpage_tl1(uint64_t pfnum, uint64_t vcolor) 370 {} 371 372 #else /* lint */ 373 374 ENTRY_NP(vac_flushpage_tl1) 375 retry 376 SET_SIZE(vac_flushpage_tl1) 377 378 #endif /* lint */ 379 380 381 #if defined(lint) 382 383 /* ARGSUSED */ 384 void 385 vac_flushcolor(int vcolor, pfn_t pfnum) 386 {} 387 388 #else /* lint */ 389 390 ENTRY(vac_flushcolor) 391 retl 392 nop 393 SET_SIZE(vac_flushcolor) 394 395 #endif /* lint */ 396 397 398 399 #if defined(lint) 400 401 /* ARGSUSED */ 402 void 403 vac_flushcolor_tl1(uint64_t vcolor, uint64_t pfnum) 404 {} 405 406 #else /* lint */ 407 408 ENTRY(vac_flushcolor_tl1) 409 retry 410 SET_SIZE(vac_flushcolor_tl1) 411 412 #endif /* lint */ 413 414 #if defined(lint) 415 416 int 417 idsr_busy(void) 418 { 419 return (0); 420 } 421 422 #else /* lint */ 423 424 /* 425 * Determine whether or not the IDSR is busy. 426 * Entry: no arguments 427 * Returns: 1 if busy, 0 otherwise 428 */ 429 ENTRY(idsr_busy) 430 ldxa [%g0]ASI_INTR_DISPATCH_STATUS, %g1 431 clr %o0 432 btst IDSR_BUSY, %g1 433 bz,a,pt %xcc, 1f 434 mov 1, %o0 435 1: 436 retl 437 nop 438 SET_SIZE(idsr_busy) 439 440 #endif /* lint */ 441 442 #if defined(lint) 443 444 /* ARGSUSED */ 445 void 446 init_mondo(xcfunc_t *func, uint64_t arg1, uint64_t arg2) 447 {} 448 449 /* ARGSUSED */ 450 void 451 init_mondo_nocheck(xcfunc_t *func, uint64_t arg1, uint64_t arg2) 452 {} 453 454 #else /* lint */ 455 456 .global _dispatch_status_busy 457 _dispatch_status_busy: 458 .asciz "ASI_INTR_DISPATCH_STATUS error: busy" 459 .align 4 460 461 /* 462 * Setup interrupt dispatch data registers 463 * Entry: 464 * %o0 - function or inumber to call 465 * %o1, %o2 - arguments (2 uint64_t's) 466 */ 467 .seg "text" 468 469 ENTRY(init_mondo) 470 #ifdef DEBUG 471 ! 472 ! IDSR should not be busy at the moment 473 ! 474 ldxa [%g0]ASI_INTR_DISPATCH_STATUS, %g1 475 btst IDSR_BUSY, %g1 476 bz,pt %xcc, 1f 477 nop 478 sethi %hi(_dispatch_status_busy), %o0 479 call panic 480 or %o0, %lo(_dispatch_status_busy), %o0 481 #endif /* DEBUG */ 482 483 ALTENTRY(init_mondo_nocheck) 484 ! 485 ! interrupt vector dispatch data reg 0 486 ! 487 1: 488 mov IDDR_0, %g1 489 mov IDDR_1, %g2 490 mov IDDR_2, %g3 491 stxa %o0, [%g1]ASI_INTR_DISPATCH 492 493 ! 494 ! interrupt vector dispatch data reg 1 495 ! 496 stxa %o1, [%g2]ASI_INTR_DISPATCH 497 498 ! 499 ! interrupt vector dispatch data reg 2 500 ! 501 stxa %o2, [%g3]ASI_INTR_DISPATCH 502 503 membar #Sync 504 retl 505 nop 506 SET_SIZE(init_mondo_nocheck) 507 SET_SIZE(init_mondo) 508 509 #endif /* lint */ 510 511 512 #if defined(lint) 513 514 /* ARGSUSED */ 515 void 516 shipit(int upaid, int bn) 517 { return; } 518 519 #else /* lint */ 520 521 /* 522 * Ship mondo to aid using busy/nack pair bn 523 */ 524 ENTRY_NP(shipit) 525 sll %o0, IDCR_PID_SHIFT, %g1 ! IDCR<23:14> = agent id 526 sll %o1, IDCR_BN_SHIFT, %g2 ! IDCR<28:24> = b/n pair 527 or %g1, IDCR_OFFSET, %g1 ! IDCR<13:0> = 0x70 528 or %g1, %g2, %g1 529 stxa %g0, [%g1]ASI_INTR_DISPATCH ! interrupt vector dispatch 530 membar #Sync 531 retl 532 nop 533 SET_SIZE(shipit) 534 535 #endif /* lint */ 536 537 538 #if defined(lint) 539 540 /* ARGSUSED */ 541 void 542 flush_instr_mem(caddr_t vaddr, size_t len) 543 {} 544 545 #else /* lint */ 546 547 /* 548 * flush_instr_mem: 549 * Flush 1 page of the I-$ starting at vaddr 550 * %o0 vaddr 551 * %o1 bytes to be flushed 552 * 553 * SPARC64-VI maintains consistency of the on-chip Instruction Cache with 554 * the stores from all processors so that a FLUSH instruction is only needed 555 * to ensure pipeline is consistent. This means a single flush is sufficient at 556 * the end of a sequence of stores that updates the instruction stream to 557 * ensure correct operation. 558 */ 559 560 ENTRY(flush_instr_mem) 561 flush %o0 ! address irrelevant 562 retl 563 nop 564 SET_SIZE(flush_instr_mem) 565 566 #endif /* lint */ 567 568 569 /* 570 * flush_ecache: 571 * %o0 - 64 bit physical address 572 * %o1 - ecache size 573 * %o2 - ecache linesize 574 */ 575 #if defined(lint) 576 577 /*ARGSUSED*/ 578 void 579 flush_ecache(uint64_t physaddr, size_t ecache_size, size_t ecache_linesize) 580 {} 581 582 #else /* !lint */ 583 584 ENTRY(flush_ecache) 585 586 /* 587 * Flush the entire Ecache. 588 */ 589 ECACHE_FLUSHALL(%o1, %o2, %o0, %o4) 590 retl 591 nop 592 SET_SIZE(flush_ecache) 593 594 #endif /* lint */ 595 596 #if defined(lint) 597 598 /*ARGSUSED*/ 599 void 600 kdi_flush_idcache(int dcache_size, int dcache_lsize, int icache_size, 601 int icache_lsize) 602 { 603 } 604 605 #else /* lint */ 606 607 /* 608 * I/D cache flushing is not needed for OPL processors 609 */ 610 ENTRY(kdi_flush_idcache) 611 retl 612 nop 613 SET_SIZE(kdi_flush_idcache) 614 615 #endif /* lint */ 616 617 #ifdef TRAPTRACE 618 /* 619 * Simplified trap trace macro for OPL. Adapted from us3. 620 */ 621 #define OPL_TRAPTRACE(ptr, scr1, scr2, label) \ 622 CPU_INDEX(scr1, ptr); \ 623 sll scr1, TRAPTR_SIZE_SHIFT, scr1; \ 624 set trap_trace_ctl, ptr; \ 625 add ptr, scr1, scr1; \ 626 ld [scr1 + TRAPTR_LIMIT], ptr; \ 627 tst ptr; \ 628 be,pn %icc, label/**/1; \ 629 ldx [scr1 + TRAPTR_PBASE], ptr; \ 630 ld [scr1 + TRAPTR_OFFSET], scr1; \ 631 add ptr, scr1, ptr; \ 632 rd %asi, scr2; \ 633 wr %g0, TRAPTR_ASI, %asi; \ 634 rd STICK, scr1; \ 635 stxa scr1, [ptr + TRAP_ENT_TICK]%asi; \ 636 rdpr %tl, scr1; \ 637 stha scr1, [ptr + TRAP_ENT_TL]%asi; \ 638 rdpr %tt, scr1; \ 639 stha scr1, [ptr + TRAP_ENT_TT]%asi; \ 640 rdpr %tpc, scr1; \ 641 stna scr1, [ptr + TRAP_ENT_TPC]%asi; \ 642 rdpr %tstate, scr1; \ 643 stxa scr1, [ptr + TRAP_ENT_TSTATE]%asi; \ 644 stna %sp, [ptr + TRAP_ENT_SP]%asi; \ 645 stna %g0, [ptr + TRAP_ENT_TR]%asi; \ 646 stna %g0, [ptr + TRAP_ENT_F1]%asi; \ 647 stna %g0, [ptr + TRAP_ENT_F2]%asi; \ 648 stna %g0, [ptr + TRAP_ENT_F3]%asi; \ 649 stna %g0, [ptr + TRAP_ENT_F4]%asi; \ 650 wr %g0, scr2, %asi; \ 651 CPU_INDEX(ptr, scr1); \ 652 sll ptr, TRAPTR_SIZE_SHIFT, ptr; \ 653 set trap_trace_ctl, scr1; \ 654 add scr1, ptr, ptr; \ 655 ld [ptr + TRAPTR_OFFSET], scr1; \ 656 ld [ptr + TRAPTR_LIMIT], scr2; \ 657 st scr1, [ptr + TRAPTR_LAST_OFFSET]; \ 658 add scr1, TRAP_ENT_SIZE, scr1; \ 659 sub scr2, TRAP_ENT_SIZE, scr2; \ 660 cmp scr1, scr2; \ 661 movge %icc, 0, scr1; \ 662 st scr1, [ptr + TRAPTR_OFFSET]; \ 663 label/**/1: 664 #endif /* TRAPTRACE */ 665 666 667 668 /* 669 * Macros facilitating error handling. 670 */ 671 672 /* 673 * Save alternative global registers reg1, reg2, reg3 674 * to scratchpad registers 1, 2, 3 respectively. 675 */ 676 #define OPL_SAVE_GLOBAL(reg1, reg2, reg3) \ 677 stxa reg1, [%g0]ASI_SCRATCHPAD ;\ 678 mov OPL_SCRATCHPAD_SAVE_AG2, reg1 ;\ 679 stxa reg2, [reg1]ASI_SCRATCHPAD ;\ 680 mov OPL_SCRATCHPAD_SAVE_AG3, reg1 ;\ 681 stxa reg3, [reg1]ASI_SCRATCHPAD 682 683 /* 684 * Restore alternative global registers reg1, reg2, reg3 685 * from scratchpad registers 1, 2, 3 respectively. 686 */ 687 #define OPL_RESTORE_GLOBAL(reg1, reg2, reg3) \ 688 mov OPL_SCRATCHPAD_SAVE_AG3, reg1 ;\ 689 ldxa [reg1]ASI_SCRATCHPAD, reg3 ;\ 690 mov OPL_SCRATCHPAD_SAVE_AG2, reg1 ;\ 691 ldxa [reg1]ASI_SCRATCHPAD, reg2 ;\ 692 ldxa [%g0]ASI_SCRATCHPAD, reg1 693 694 /* 695 * Logs value `val' into the member `offset' of a structure 696 * at physical address `pa' 697 */ 698 #define LOG_REG(pa, offset, val) \ 699 add pa, offset, pa ;\ 700 stxa val, [pa]ASI_MEM 701 702 #define FLUSH_ALL_TLB(tmp1) \ 703 set DEMAP_ALL_TYPE, tmp1 ;\ 704 stxa %g0, [tmp1]ASI_ITLB_DEMAP ;\ 705 stxa %g0, [tmp1]ASI_DTLB_DEMAP ;\ 706 sethi %hi(FLUSH_ADDR), tmp1 ;\ 707 flush tmp1 708 709 /* 710 * Extracts the Physaddr to Logging Buffer field of the OPL_SCRATCHPAD_ERRLOG 711 * scratch register by zeroing all other fields. Result is in pa. 712 */ 713 #define LOG_ADDR(pa) \ 714 mov OPL_SCRATCHPAD_ERRLOG, pa ;\ 715 ldxa [pa]ASI_SCRATCHPAD, pa ;\ 716 sllx pa, 64-ERRLOG_REG_EIDR_SHIFT, pa ;\ 717 srlx pa, 64-ERRLOG_REG_EIDR_SHIFT+ERRLOG_REG_ERR_SHIFT, pa ;\ 718 sllx pa, ERRLOG_REG_ERR_SHIFT, pa 719 720 /* 721 * Advance the per-cpu error log buffer pointer to the next 722 * ERRLOG_SZ entry, making sure that it will modulo (wraparound) 723 * ERRLOG_BUFSIZ boundary. The args logpa, bufmask, tmp are 724 * unused input registers for this macro. 725 * 726 * Algorithm: 727 * 1. logpa = contents of errorlog scratchpad register 728 * 2. bufmask = ERRLOG_BUFSIZ - 1 729 * 3. tmp = logpa & ~(bufmask) (tmp is now logbase) 730 * 4. logpa += ERRLOG_SZ 731 * 5. logpa = logpa & bufmask (get new offset to logbase) 732 * 4. logpa = tmp | logpa 733 * 7. write logpa back into errorlog scratchpad register 734 * 735 * new logpa = (logpa & ~bufmask) | ((logpa + ERRLOG_SZ) & bufmask) 736 * 737 */ 738 #define UPDATE_LOGADD(logpa, bufmask, tmp) \ 739 set OPL_SCRATCHPAD_ERRLOG, tmp ;\ 740 ldxa [tmp]ASI_SCRATCHPAD, logpa ;\ 741 set (ERRLOG_BUFSZ-1), bufmask ;\ 742 andn logpa, bufmask, tmp ;\ 743 add logpa, ERRLOG_SZ, logpa ;\ 744 and logpa, bufmask, logpa ;\ 745 or tmp, logpa, logpa ;\ 746 set OPL_SCRATCHPAD_ERRLOG, tmp ;\ 747 stxa logpa, [tmp]ASI_SCRATCHPAD 748 749 /* Log error status registers into the log buffer */ 750 #define LOG_SYNC_REG(sfsr, sfar, tmp) \ 751 LOG_ADDR(tmp) ;\ 752 LOG_REG(tmp, LOG_SFSR_OFF, sfsr) ;\ 753 LOG_ADDR(tmp) ;\ 754 mov tmp, sfsr ;\ 755 LOG_REG(tmp, LOG_SFAR_OFF, sfar) ;\ 756 rd STICK, sfar ;\ 757 mov sfsr, tmp ;\ 758 LOG_REG(tmp, LOG_STICK_OFF, sfar) ;\ 759 rdpr %tl, tmp ;\ 760 sllx tmp, 32, sfar ;\ 761 rdpr %tt, tmp ;\ 762 or sfar, tmp, sfar ;\ 763 mov sfsr, tmp ;\ 764 LOG_REG(tmp, LOG_TL_OFF, sfar) ;\ 765 set OPL_SCRATCHPAD_ERRLOG, tmp ;\ 766 ldxa [tmp]ASI_SCRATCHPAD, sfar ;\ 767 mov sfsr, tmp ;\ 768 LOG_REG(tmp, LOG_ASI3_OFF, sfar) ;\ 769 rdpr %tpc, sfar ;\ 770 mov sfsr, tmp ;\ 771 LOG_REG(tmp, LOG_TPC_OFF, sfar) ;\ 772 UPDATE_LOGADD(sfsr, sfar, tmp) 773 774 #define LOG_UGER_REG(uger, tmp, tmp2) \ 775 LOG_ADDR(tmp) ;\ 776 mov tmp, tmp2 ;\ 777 LOG_REG(tmp2, LOG_UGER_OFF, uger) ;\ 778 mov tmp, uger ;\ 779 rd STICK, tmp2 ;\ 780 LOG_REG(tmp, LOG_STICK_OFF, tmp2) ;\ 781 rdpr %tl, tmp ;\ 782 sllx tmp, 32, tmp2 ;\ 783 rdpr %tt, tmp ;\ 784 or tmp2, tmp, tmp2 ;\ 785 mov uger, tmp ;\ 786 LOG_REG(tmp, LOG_TL_OFF, tmp2) ;\ 787 set OPL_SCRATCHPAD_ERRLOG, tmp2 ;\ 788 ldxa [tmp2]ASI_SCRATCHPAD, tmp2 ;\ 789 mov uger, tmp ;\ 790 LOG_REG(tmp, LOG_ASI3_OFF, tmp2) ;\ 791 rdpr %tstate, tmp2 ;\ 792 mov uger, tmp ;\ 793 LOG_REG(tmp, LOG_TSTATE_OFF, tmp2) ;\ 794 rdpr %tpc, tmp2 ;\ 795 mov uger, tmp ;\ 796 LOG_REG(tmp, LOG_TPC_OFF, tmp2) ;\ 797 UPDATE_LOGADD(uger, tmp, tmp2) 798 799 /* 800 * Scrub the STICK_COMPARE register to clear error by updating 801 * it to a reasonable value for interrupt generation. 802 * Ensure that we observe the CPU_ENABLE flag so that we 803 * don't accidentally enable TICK interrupt in STICK_COMPARE 804 * i.e. no clock interrupt will be generated if CPU_ENABLE flag 805 * is off. 806 */ 807 #define UPDATE_STICK_COMPARE(tmp1, tmp2) \ 808 CPU_ADDR(tmp1, tmp2) ;\ 809 lduh [tmp1 + CPU_FLAGS], tmp2 ;\ 810 andcc tmp2, CPU_ENABLE, %g0 ;\ 811 set OPL_UGER_STICK_DIFF, tmp2 ;\ 812 rd STICK, tmp1 ;\ 813 add tmp1, tmp2, tmp1 ;\ 814 mov 1, tmp2 ;\ 815 sllx tmp2, TICKINT_DIS_SHFT, tmp2 ;\ 816 or tmp1, tmp2, tmp2 ;\ 817 movnz %xcc, tmp1, tmp2 ;\ 818 wr tmp2, %g0, STICK_COMPARE 819 820 /* 821 * Reset registers that may be corrupted by IAUG_CRE error. 822 * To update interrupt handling related registers force the 823 * clock interrupt. 824 */ 825 #define IAG_CRE(tmp1, tmp2) \ 826 set OPL_SCRATCHPAD_ERRLOG, tmp1 ;\ 827 ldxa [tmp1]ASI_SCRATCHPAD, tmp1 ;\ 828 srlx tmp1, ERRLOG_REG_EIDR_SHIFT, tmp1 ;\ 829 set ERRLOG_REG_EIDR_MASK, tmp2 ;\ 830 and tmp1, tmp2, tmp1 ;\ 831 stxa tmp1, [%g0]ASI_EIDR ;\ 832 wr %g0, 0, SOFTINT ;\ 833 sethi %hi(hres_last_tick), tmp1 ;\ 834 ldx [tmp1 + %lo(hres_last_tick)], tmp1 ;\ 835 set OPL_UGER_STICK_DIFF, tmp2 ;\ 836 add tmp1, tmp2, tmp1 ;\ 837 wr tmp1, %g0, STICK ;\ 838 UPDATE_STICK_COMPARE(tmp1, tmp2) 839 840 841 #define CLEAR_FPREGS(tmp) \ 842 wr %g0, FPRS_FEF, %fprs ;\ 843 wr %g0, %g0, %gsr ;\ 844 sethi %hi(opl_clr_freg), tmp ;\ 845 or tmp, %lo(opl_clr_freg), tmp ;\ 846 ldx [tmp], %fsr ;\ 847 fzero %d0 ;\ 848 fzero %d2 ;\ 849 fzero %d4 ;\ 850 fzero %d6 ;\ 851 fzero %d8 ;\ 852 fzero %d10 ;\ 853 fzero %d12 ;\ 854 fzero %d14 ;\ 855 fzero %d16 ;\ 856 fzero %d18 ;\ 857 fzero %d20 ;\ 858 fzero %d22 ;\ 859 fzero %d24 ;\ 860 fzero %d26 ;\ 861 fzero %d28 ;\ 862 fzero %d30 ;\ 863 fzero %d32 ;\ 864 fzero %d34 ;\ 865 fzero %d36 ;\ 866 fzero %d38 ;\ 867 fzero %d40 ;\ 868 fzero %d42 ;\ 869 fzero %d44 ;\ 870 fzero %d46 ;\ 871 fzero %d48 ;\ 872 fzero %d50 ;\ 873 fzero %d52 ;\ 874 fzero %d54 ;\ 875 fzero %d56 ;\ 876 fzero %d58 ;\ 877 fzero %d60 ;\ 878 fzero %d62 ;\ 879 wr %g0, %g0, %fprs 880 881 #define CLEAR_GLOBALS() \ 882 mov %g0, %g1 ;\ 883 mov %g0, %g2 ;\ 884 mov %g0, %g3 ;\ 885 mov %g0, %g4 ;\ 886 mov %g0, %g5 ;\ 887 mov %g0, %g6 ;\ 888 mov %g0, %g7 889 890 /* 891 * We do not clear the alternative globals here because they 892 * are scratch registers, i.e. there is no code that reads from 893 * them without write to them firstly. In other words every 894 * read always follows write that makes extra write to the 895 * alternative globals unnecessary. 896 */ 897 #define CLEAR_GEN_REGS(tmp1, label) \ 898 set TSTATE_KERN, tmp1 ;\ 899 wrpr %g0, tmp1, %tstate ;\ 900 mov %g0, %y ;\ 901 mov %g0, %asi ;\ 902 mov %g0, %ccr ;\ 903 mov %g0, %l0 ;\ 904 mov %g0, %l1 ;\ 905 mov %g0, %l2 ;\ 906 mov %g0, %l3 ;\ 907 mov %g0, %l4 ;\ 908 mov %g0, %l5 ;\ 909 mov %g0, %l6 ;\ 910 mov %g0, %l7 ;\ 911 mov %g0, %i0 ;\ 912 mov %g0, %i1 ;\ 913 mov %g0, %i2 ;\ 914 mov %g0, %i3 ;\ 915 mov %g0, %i4 ;\ 916 mov %g0, %i5 ;\ 917 mov %g0, %i6 ;\ 918 mov %g0, %i7 ;\ 919 mov %g0, %o1 ;\ 920 mov %g0, %o2 ;\ 921 mov %g0, %o3 ;\ 922 mov %g0, %o4 ;\ 923 mov %g0, %o5 ;\ 924 mov %g0, %o6 ;\ 925 mov %g0, %o7 ;\ 926 mov %g0, %o0 ;\ 927 mov %g0, %g4 ;\ 928 mov %g0, %g5 ;\ 929 mov %g0, %g6 ;\ 930 mov %g0, %g7 ;\ 931 rdpr %tl, tmp1 ;\ 932 cmp tmp1, 1 ;\ 933 be,pt %xcc, label/**/1 ;\ 934 rdpr %pstate, tmp1 ;\ 935 wrpr tmp1, PSTATE_AG|PSTATE_IG, %pstate ;\ 936 CLEAR_GLOBALS() ;\ 937 rdpr %pstate, tmp1 ;\ 938 wrpr tmp1, PSTATE_IG|PSTATE_MG, %pstate ;\ 939 CLEAR_GLOBALS() ;\ 940 rdpr %pstate, tmp1 ;\ 941 wrpr tmp1, PSTATE_MG|PSTATE_AG, %pstate ;\ 942 ba,pt %xcc, label/**/2 ;\ 943 nop ;\ 944 label/**/1: ;\ 945 wrpr tmp1, PSTATE_AG, %pstate ;\ 946 CLEAR_GLOBALS() ;\ 947 rdpr %pstate, tmp1 ;\ 948 wrpr tmp1, PSTATE_AG, %pstate ;\ 949 label/**/2: 950 951 952 /* 953 * Reset all window related registers 954 */ 955 #define RESET_WINREG(tmp) \ 956 sethi %hi(nwin_minus_one), tmp ;\ 957 ld [tmp + %lo(nwin_minus_one)], tmp ;\ 958 wrpr %g0, tmp, %cwp ;\ 959 wrpr %g0, tmp, %cleanwin ;\ 960 sub tmp, 1, tmp ;\ 961 wrpr %g0, tmp, %cansave ;\ 962 wrpr %g0, %g0, %canrestore ;\ 963 wrpr %g0, %g0, %otherwin ;\ 964 wrpr %g0, PIL_MAX, %pil ;\ 965 wrpr %g0, WSTATE_KERN, %wstate 966 967 968 #define RESET_PREV_TSTATE(tmp1, tmp2, label) \ 969 rdpr %tl, tmp1 ;\ 970 subcc tmp1, 1, tmp1 ;\ 971 bz,pt %xcc, label/**/1 ;\ 972 nop ;\ 973 wrpr tmp1, %g0, %tl ;\ 974 set TSTATE_KERN, tmp2 ;\ 975 wrpr tmp2, %g0, %tstate ;\ 976 wrpr %g0, %g0, %tpc ;\ 977 wrpr %g0, %g0, %tnpc ;\ 978 add tmp1, 1, tmp1 ;\ 979 wrpr tmp1, %g0, %tl ;\ 980 label/**/1: 981 982 983 /* 984 * %pstate, %pc, %npc are propagated to %tstate, %tpc, %tnpc, 985 * and we reset these regiseter here. 986 */ 987 #define RESET_CUR_TSTATE(tmp) \ 988 set TSTATE_KERN, tmp ;\ 989 wrpr %g0, tmp, %tstate ;\ 990 wrpr %g0, 0, %tpc ;\ 991 wrpr %g0, 0, %tnpc ;\ 992 RESET_WINREG(tmp) 993 994 /* 995 * In case of urgent errors some MMU registers may be 996 * corrupted, so we set here some reasonable values for 997 * them. Note that resetting MMU registers also reset the context 998 * info, we will need to reset the window registers to prevent 999 * spill/fill that depends on context info for correct behaviour. 1000 * Note that the TLBs must be flushed before programming the context 1001 * registers. 1002 */ 1003 1004 #if !defined(lint) 1005 #define RESET_MMU_REGS(tmp1, tmp2, tmp3) \ 1006 FLUSH_ALL_TLB(tmp1) ;\ 1007 set MMU_PCONTEXT, tmp1 ;\ 1008 sethi %hi(kcontextreg), tmp2 ;\ 1009 ldx [tmp2 + %lo(kcontextreg)], tmp2 ;\ 1010 stxa tmp2, [tmp1]ASI_DMMU ;\ 1011 set MMU_SCONTEXT, tmp1 ;\ 1012 stxa tmp2, [tmp1]ASI_DMMU ;\ 1013 sethi %hi(ktsb_base), tmp1 ;\ 1014 ldx [tmp1 + %lo(ktsb_base)], tmp2 ;\ 1015 mov MMU_TSB, tmp3 ;\ 1016 stxa tmp2, [tmp3]ASI_IMMU ;\ 1017 stxa tmp2, [tmp3]ASI_DMMU ;\ 1018 membar #Sync ;\ 1019 RESET_WINREG(tmp1) 1020 1021 #define RESET_TSB_TAGPTR(tmp) \ 1022 set MMU_TAG_ACCESS, tmp ;\ 1023 stxa %g0, [tmp]ASI_IMMU ;\ 1024 stxa %g0, [tmp]ASI_DMMU ;\ 1025 membar #Sync 1026 #endif /* lint */ 1027 1028 /* 1029 * In case of errors in the MMU_TSB_PREFETCH registers we have to 1030 * reset them. We can use "0" as the reset value, this way we set 1031 * the "V" bit of the registers to 0, which will disable the prefetch 1032 * so the values of the other fields are irrelevant. 1033 */ 1034 #if !defined(lint) 1035 #define RESET_TSB_PREFETCH(tmp) \ 1036 set VA_UTSBPREF_8K, tmp ;\ 1037 stxa %g0, [tmp]ASI_ITSB_PREFETCH ;\ 1038 set VA_UTSBPREF_4M, tmp ;\ 1039 stxa %g0, [tmp]ASI_ITSB_PREFETCH ;\ 1040 set VA_KTSBPREF_8K, tmp ;\ 1041 stxa %g0, [tmp]ASI_ITSB_PREFETCH ;\ 1042 set VA_KTSBPREF_4M, tmp ;\ 1043 stxa %g0, [tmp]ASI_ITSB_PREFETCH ;\ 1044 set VA_UTSBPREF_8K, tmp ;\ 1045 stxa %g0, [tmp]ASI_DTSB_PREFETCH ;\ 1046 set VA_UTSBPREF_4M, tmp ;\ 1047 stxa %g0, [tmp]ASI_DTSB_PREFETCH ;\ 1048 set VA_KTSBPREF_8K, tmp ;\ 1049 stxa %g0, [tmp]ASI_DTSB_PREFETCH ;\ 1050 set VA_KTSBPREF_4M, tmp ;\ 1051 stxa %g0, [tmp]ASI_DTSB_PREFETCH 1052 #endif /* lint */ 1053 1054 /* 1055 * In case of errors in the MMU_SHARED_CONTEXT register we have to 1056 * reset its value. We can use "0" as the reset value, it will put 1057 * 0 in the IV field disabling the shared context support, and 1058 * making values of all the other fields of the register irrelevant. 1059 */ 1060 #if !defined(lint) 1061 #define RESET_SHARED_CTXT(tmp) \ 1062 set MMU_SHARED_CONTEXT, tmp ;\ 1063 stxa %g0, [tmp]ASI_DMMU 1064 #endif /* lint */ 1065 1066 /* 1067 * RESET_TO_PRIV() 1068 * 1069 * In many cases, we need to force the thread into privilege mode because 1070 * privilege mode is only thing in which the system continue to work 1071 * due to undeterminable user mode information that come from register 1072 * corruption. 1073 * 1074 * - opl_uger_ctxt 1075 * If the error is secondary TSB related register parity, we have no idea 1076 * what value is supposed to be for it. 1077 * 1078 * The below three cases %tstate is not accessible until it is overwritten 1079 * with some value, so we have no clue if the thread was running on user mode 1080 * or not 1081 * - opl_uger_pstate 1082 * If the error is %pstate parity, it propagates to %tstate. 1083 * - opl_uger_tstate 1084 * No need to say the reason 1085 * - opl_uger_r 1086 * If the error is %ccr or %asi parity, it propagates to %tstate 1087 * 1088 * For the above four cases, user mode info may not be available for 1089 * sys_trap() and user_trap() to work consistently. So we have to force 1090 * the thread into privilege mode. 1091 * 1092 * Forcing the thread to privilege mode requires forcing 1093 * regular %g7 to be CPU_THREAD. Because if it was running on user mode, 1094 * %g7 will be set in user_trap(). Also since the %sp may be in 1095 * an inconsistent state, we need to do a stack reset and switch to 1096 * something we know i.e. current thread's kernel stack. 1097 * We also reset the window registers and MMU registers just to 1098 * make sure. 1099 * 1100 * To set regular %g7, we need to clear PSTATE_AG bit and need to 1101 * use one local register. Note that we are panicking and will never 1102 * unwind back so it is ok to clobber a local. 1103 * 1104 * If the thread was running in user mode, the %tpc value itself might be 1105 * within the range of OBP addresses. %tpc must be forced to be zero to prevent 1106 * sys_trap() from going to prom_trap() 1107 * 1108 */ 1109 #define RESET_TO_PRIV(tmp, tmp1, tmp2, local) \ 1110 RESET_MMU_REGS(tmp, tmp1, tmp2) ;\ 1111 CPU_ADDR(tmp, tmp1) ;\ 1112 ldx [tmp + CPU_THREAD], local ;\ 1113 ldx [local + T_STACK], tmp ;\ 1114 sub tmp, STACK_BIAS, %sp ;\ 1115 rdpr %pstate, tmp ;\ 1116 wrpr tmp, PSTATE_AG, %pstate ;\ 1117 mov local, %g7 ;\ 1118 rdpr %pstate, local ;\ 1119 wrpr local, PSTATE_AG, %pstate ;\ 1120 wrpr %g0, 1, %tl ;\ 1121 set TSTATE_KERN, tmp ;\ 1122 rdpr %cwp, tmp1 ;\ 1123 or tmp, tmp1, tmp ;\ 1124 wrpr tmp, %g0, %tstate ;\ 1125 wrpr %g0, %tpc 1126 1127 1128 #if defined(lint) 1129 1130 void 1131 ce_err(void) 1132 {} 1133 1134 #else /* lint */ 1135 1136 /* 1137 * We normally don't expect CE traps since we disable the 1138 * 0x63 trap reporting at the start of day. There is a 1139 * small window before we disable them, so let check for 1140 * it. Otherwise, panic. 1141 */ 1142 1143 .align 128 1144 ENTRY_NP(ce_err) 1145 mov AFSR_ECR, %g1 1146 ldxa [%g1]ASI_ECR, %g1 1147 andcc %g1, ASI_ECR_RTE_UE | ASI_ECR_RTE_CEDG, %g0 1148 bz,pn %xcc, 1f 1149 nop 1150 retry 1151 1: 1152 /* 1153 * We did disabled the 0x63 trap reporting. 1154 * This shouldn't happen - panic. 1155 */ 1156 set trap, %g1 1157 rdpr %tt, %g3 1158 sethi %hi(sys_trap), %g5 1159 jmp %g5 + %lo(sys_trap) 1160 sub %g0, 1, %g4 1161 SET_SIZE(ce_err) 1162 1163 #endif /* lint */ 1164 1165 1166 #if defined(lint) 1167 1168 void 1169 ce_err_tl1(void) 1170 {} 1171 1172 #else /* lint */ 1173 1174 /* 1175 * We don't use trap for CE detection. 1176 */ 1177 ENTRY_NP(ce_err_tl1) 1178 set trap, %g1 1179 rdpr %tt, %g3 1180 sethi %hi(sys_trap), %g5 1181 jmp %g5 + %lo(sys_trap) 1182 sub %g0, 1, %g4 1183 SET_SIZE(ce_err_tl1) 1184 1185 #endif /* lint */ 1186 1187 1188 #if defined(lint) 1189 1190 void 1191 async_err(void) 1192 {} 1193 1194 #else /* lint */ 1195 1196 /* 1197 * async_err is the default handler for IAE/DAE traps. 1198 * For OPL, we patch in the right handler at start of day. 1199 * But if a IAE/DAE trap get generated before the handler 1200 * is patched, panic. 1201 */ 1202 ENTRY_NP(async_err) 1203 set trap, %g1 1204 rdpr %tt, %g3 1205 sethi %hi(sys_trap), %g5 1206 jmp %g5 + %lo(sys_trap) 1207 sub %g0, 1, %g4 1208 SET_SIZE(async_err) 1209 1210 #endif /* lint */ 1211 1212 #if defined(lint) 1213 void 1214 opl_sync_trap(void) 1215 {} 1216 #else /* lint */ 1217 1218 .seg ".data" 1219 .global opl_clr_freg 1220 .global opl_cpu0_err_log 1221 1222 .align 16 1223 opl_clr_freg: 1224 .word 0 1225 .align 16 1226 1227 .align MMU_PAGESIZE 1228 opl_cpu0_err_log: 1229 .skip MMU_PAGESIZE 1230 1231 /* 1232 * Common synchronous error trap handler (tt=0xA, 0x32) 1233 * All TL=0 and TL>0 0xA and 0x32 traps vector to this handler. 1234 * The error handling can be best summarized as follows: 1235 * 0. Do TRAPTRACE if enabled. 1236 * 1. Save globals %g1, %g2 & %g3 onto the scratchpad regs. 1237 * 2. The SFSR register is read and verified as valid by checking 1238 * SFSR.FV bit being set. If the SFSR.FV is not set, the 1239 * error cases cannot be decoded/determined and the SFPAR 1240 * register that contain the physical faultaddr is also 1241 * not valid. Also the SPFAR is only valid for UE/TO/BERR error 1242 * cases. Assuming the SFSR.FV is valid: 1243 * - BERR(bus error)/TO(timeout)/UE case 1244 * If any of these error cases are detected, read the SFPAR 1245 * to get the faultaddress. Generate ereport. 1246 * - TLB Parity case (only recoverable case) 1247 * For DAE, read SFAR for the faultaddress. For IAE, 1248 * use %tpc for faultaddress (SFAR is not valid in IAE) 1249 * Flush all the tlbs. 1250 * Subtract one from the recoverable error count stored in 1251 * the error log scratch register. If the threshold limit 1252 * is reached (zero) - generate ereport. Else 1253 * restore globals and retry (no ereport is generated). 1254 * - TLB Multiple hits 1255 * For DAE, read SFAR for the faultaddress. For IAE, 1256 * use %tpc for faultaddress (SFAR is not valid in IAE). 1257 * Flush all tlbs and generate ereport. 1258 * 3. TL=0 and TL>0 considerations 1259 * - Since both TL=0 & TL>1 traps are made to vector into 1260 * the same handler, the underlying assumption/design here is 1261 * that any nested error condition (if happens) occurs only 1262 * in the handler and the system is assumed to eventually 1263 * Red-mode. With this philosophy in mind, the recoverable 1264 * TLB Parity error case never check the TL level before it 1265 * retry. Note that this is ok for the TL>1 case (assuming we 1266 * don't have a nested error) since we always save the globals 1267 * %g1, %g2 & %g3 whenever we enter this trap handler. 1268 * - Additional TL=0 vs TL>1 handling includes: 1269 * - For UE error occuring under TL>1, special handling 1270 * is added to prevent the unlikely chance of a cpu-lockup 1271 * when a UE was originally detected in user stack and 1272 * the spill trap handler taken from sys_trap() so happened 1273 * to reference the same UE location. Under the above 1274 * condition (TL>1 and UE error), paranoid code is added 1275 * to reset window regs so that spill traps can't happen 1276 * during the unwind back to TL=0 handling. 1277 * Note that we can do that because we are not returning 1278 * back. 1279 * 4. Ereport generation. 1280 * - Ereport generation is performed when we unwind to the TL=0 1281 * handling code via sys_trap(). on_trap()/lofault protection 1282 * will apply there. 1283 * 1284 */ 1285 ENTRY_NP(opl_sync_trap) 1286 #ifdef TRAPTRACE 1287 OPL_TRAPTRACE(%g1, %g2, %g3, opl_sync_trap_lb) 1288 rdpr %tt, %g1 1289 #endif /* TRAPTRACE */ 1290 cmp %g1, T_INSTR_ERROR 1291 bne,pt %xcc, 0f 1292 mov MMU_SFSR, %g3 1293 ldxa [%g3]ASI_IMMU, %g1 ! IAE trap case tt = 0xa 1294 andcc %g1, SFSR_FV, %g0 1295 bz,a,pn %xcc, 2f ! Branch if SFSR is invalid and 1296 rdpr %tpc, %g2 ! use %tpc for faultaddr instead 1297 1298 sethi %hi(SFSR_UE|SFSR_BERR|SFSR_TO), %g3 1299 andcc %g1, %g3, %g0 ! Check for UE/BERR/TO errors 1300 bz,a,pt %xcc, 1f ! Branch if not UE/BERR/TO and 1301 rdpr %tpc, %g2 ! use %tpc as faultaddr 1302 set OPL_MMU_SFPAR, %g3 ! In the UE/BERR/TO cases, use 1303 ba,pt %xcc, 2f ! SFPAR as faultaddr 1304 ldxa [%g3]ASI_IMMU, %g2 1305 0: 1306 ldxa [%g3]ASI_DMMU, %g1 ! DAE trap case tt = 0x32 1307 andcc %g1, SFSR_FV, %g0 1308 bnz,pt %xcc, 7f ! branch if SFSR.FV is valid 1309 mov MMU_SFAR, %g2 ! set %g2 to use SFAR 1310 ba,pt %xcc, 2f ! SFSR.FV is not valid, read SFAR 1311 ldxa [%g2]ASI_DMMU, %g2 ! for faultaddr 1312 7: 1313 sethi %hi(SFSR_UE|SFSR_BERR|SFSR_TO), %g3 1314 andcc %g1, %g3, %g0 ! Check UE/BERR/TO for valid SFPAR 1315 movnz %xcc, OPL_MMU_SFPAR, %g2 ! Use SFPAR instead of SFAR for 1316 ldxa [%g2]ASI_DMMU, %g2 ! faultaddr 1317 1: 1318 sethi %hi(SFSR_TLB_PRT), %g3 1319 andcc %g1, %g3, %g0 1320 bz,pt %xcc, 8f ! branch for TLB multi-hit check 1321 nop 1322 /* 1323 * This is the TLB parity error case and it is the 1324 * only retryable error case. 1325 * Only %g1, %g2 and %g3 are allowed 1326 */ 1327 FLUSH_ALL_TLB(%g3) 1328 set OPL_SCRATCHPAD_ERRLOG, %g3 1329 ldxa [%g3]ASI_SCRATCHPAD, %g3 ! Read errlog scratchreg 1330 and %g3, ERRLOG_REG_NUMERR_MASK, %g3! Extract the error count 1331 subcc %g3, 1, %g0 ! Subtract one from the count 1332 bz,pn %xcc, 2f ! too many TLB parity errs in a certain 1333 nop ! period, branch to generate ereport 1334 LOG_SYNC_REG(%g1, %g2, %g3) ! Record into the error log 1335 set OPL_SCRATCHPAD_ERRLOG, %g3 1336 ldxa [%g3]ASI_SCRATCHPAD, %g2 1337 sub %g2, 1, %g2 ! decrement error counter by 1 1338 stxa %g2, [%g3]ASI_SCRATCHPAD ! update the errlog scratchreg 1339 OPL_RESTORE_GLOBAL(%g1, %g2, %g3) 1340 retry 1341 8: 1342 sethi %hi(SFSR_TLB_MUL), %g3 1343 andcc %g1, %g3, %g0 1344 bz,pt %xcc, 2f ! check for the TLB multi-hit errors 1345 nop 1346 FLUSH_ALL_TLB(%g3) 1347 2: 1348 /* 1349 * non-retryable error handling 1350 * now we can use other registers since 1351 * we will not be returning back 1352 */ 1353 mov %g1, %g5 ! %g5 = SFSR 1354 mov %g2, %g6 ! %g6 = SFPAR or SFAR/tpc 1355 LOG_SYNC_REG(%g1, %g2, %g3) ! Record into the error log 1356 1357 /* 1358 * Special case for UE on user stack. 1359 * There is a possibility that the same error may come back here 1360 * by touching the same UE in spill trap handler taken from 1361 * sys_trap(). It ends up with an infinite loop causing a cpu lockup. 1362 * Conditions for this handling this case are: 1363 * - SFSR_FV is valid and SFSR_UE is set 1364 * - we are at TL > 1 1365 * If the above conditions are true, we force %cansave to be a 1366 * big number to prevent spill trap in sys_trap(). Note that 1367 * we will not be returning back. 1368 */ 1369 rdpr %tt, %g4 ! %g4 == ttype 1370 rdpr %tl, %g1 ! %g1 == tl 1371 cmp %g1, 1 ! Check if TL == 1 1372 be,pt %xcc, 3f ! branch if we came from TL=0 1373 nop 1374 andcc %g5, SFSR_FV, %g0 ! see if SFSR.FV is valid 1375 bz,pn %xcc, 4f ! branch, checking UE is meaningless 1376 sethi %hi(SFSR_UE), %g2 1377 andcc %g5, %g2, %g0 ! check for UE 1378 bz,pt %xcc, 4f ! branch if not UE 1379 nop 1380 RESET_WINREG(%g1) ! reset windows to prevent spills 1381 4: 1382 RESET_USER_RTT_REGS(%g2, %g3, opl_sync_trap_resetskip) 1383 opl_sync_trap_resetskip: 1384 mov %g5, %g3 ! pass SFSR to the 3rd arg 1385 mov %g6, %g2 ! pass SFAR to the 2nd arg 1386 set opl_cpu_isync_tl1_error, %g1 1387 set opl_cpu_dsync_tl1_error, %g6 1388 cmp %g4, T_INSTR_ERROR 1389 movne %icc, %g6, %g1 1390 ba,pt %icc, 6f 1391 nop 1392 3: 1393 mov %g5, %g3 ! pass SFSR to the 3rd arg 1394 mov %g6, %g2 ! pass SFAR to the 2nd arg 1395 set opl_cpu_isync_tl0_error, %g1 1396 set opl_cpu_dsync_tl0_error, %g6 1397 cmp %g4, T_INSTR_ERROR 1398 movne %icc, %g6, %g1 1399 6: 1400 sethi %hi(sys_trap), %g5 1401 jmp %g5 + %lo(sys_trap) 1402 mov PIL_15, %g4 1403 SET_SIZE(opl_sync_trap) 1404 #endif /* lint */ 1405 1406 #if defined(lint) 1407 void 1408 opl_uger_trap(void) 1409 {} 1410 #else /* lint */ 1411 /* 1412 * Common Urgent error trap handler (tt=0x40) 1413 * All TL=0 and TL>0 0x40 traps vector to this handler. 1414 * The error handling can be best summarized as follows: 1415 * 1. Read the Urgent error status register (UGERSR) 1416 * Faultaddress is N/A here and it is not collected. 1417 * 2. Check to see if we have a multiple errors case 1418 * If so, we enable WEAK_ED (weak error detection) bit 1419 * to prevent any potential error storms and branch directly 1420 * to generate ereport. (we don't decode/handle individual 1421 * error cases when we get a multiple error situation) 1422 * 3. Now look for the recoverable error cases which include 1423 * IUG_DTLB, IUG_ITLB or COREERR errors. If any of the 1424 * recoverable errors are detected, do the following: 1425 * - Flush all tlbs. 1426 * - Verify that we came from TL=0, if not, generate 1427 * ereport. Note that the reason we don't recover 1428 * at TL>0 is because the AGs might be corrupted or 1429 * inconsistent. We can't save/restore them into 1430 * the scratchpad regs like we did for opl_sync_trap(). 1431 * - Check the INSTEND[5:4] bits in the UGERSR. If the 1432 * value is 0x3 (11b), this error is not recoverable. 1433 * Generate ereport. 1434 * - Subtract one from the recoverable error count stored in 1435 * the error log scratch register. If the threshold limit 1436 * is reached (zero) - generate ereport. 1437 * - If the count is within the limit, update the count 1438 * in the error log register (subtract one). Log the error 1439 * info in the log buffer. Capture traptrace if enabled. 1440 * Retry (no ereport generated) 1441 * 4. The rest of the error cases are unrecoverable and will 1442 * be handled according (flushing regs, etc as required). 1443 * For details on these error cases (UGER_CRE, UGER_CTXT, etc..) 1444 * consult the OPL cpu/mem philosophy doc. 1445 * Ereport will be generated for these errors. 1446 * 5. Ereport generation. 1447 * - Ereport generation for urgent error trap always 1448 * result in a panic when we unwind to the TL=0 handling 1449 * code via sys_trap(). on_trap()/lofault protection do 1450 * not apply there. 1451 */ 1452 ENTRY_NP(opl_uger_trap) 1453 set ASI_UGERSR, %g2 1454 ldxa [%g2]ASI_AFSR, %g1 ! Read the UGERSR reg 1455 1456 set UGESR_MULTI, %g2 1457 andcc %g1, %g2, %g0 ! Check for Multi-errs 1458 bz,pt %xcc, opl_uger_is_recover ! branch if not Multi-errs 1459 nop 1460 set AFSR_ECR, %g2 1461 ldxa [%g2]ASI_AFSR, %g3 ! Enable Weak error 1462 or %g3, ASI_ECR_WEAK_ED, %g3 ! detect mode to prevent 1463 stxa %g3, [%g2]ASI_AFSR ! potential error storms 1464 ba %xcc, opl_uger_panic1 1465 nop 1466 1467 opl_uger_is_recover: 1468 set UGESR_CAN_RECOVER, %g2 ! Check for recoverable 1469 andcc %g1, %g2, %g0 ! errors i.e.IUG_DTLB, 1470 bz,pt %xcc, opl_uger_cre ! IUG_ITLB or COREERR 1471 nop 1472 1473 /* 1474 * Fall thru to handle recoverable case 1475 * Need to do the following additional checks to determine 1476 * if this is indeed recoverable. 1477 * 1. Error trap came from TL=0 and 1478 * 2. INSTEND[5:4] bits in UGERSR is not 0x3 1479 * 3. Recoverable error count limit not reached 1480 * 1481 */ 1482 FLUSH_ALL_TLB(%g3) 1483 rdpr %tl, %g3 ! Read TL 1484 cmp %g3, 1 ! Check if we came from TL=0 1485 bne,pt %xcc, opl_uger_panic ! branch if came from TL>0 1486 nop 1487 srlx %g1, 4, %g2 ! shift INSTEND[5:4] -> [1:0] 1488 and %g2, 3, %g2 ! extract the shifted [1:0] bits 1489 cmp %g2, 3 ! check if INSTEND is recoverable 1490 be,pt %xcc, opl_uger_panic ! panic if ([1:0] = 11b) 1491 nop 1492 set OPL_SCRATCHPAD_ERRLOG, %g3 1493 ldxa [%g3]ASI_SCRATCHPAD, %g2 ! Read errlog scratch reg 1494 and %g2, ERRLOG_REG_NUMERR_MASK, %g3! Extract error count and 1495 subcc %g3, 1, %g3 ! subtract one from it 1496 bz,pt %xcc, opl_uger_panic ! If count reached zero, too many 1497 nop ! errors, branch to generate ereport 1498 sub %g2, 1, %g2 ! Subtract one from the count 1499 set OPL_SCRATCHPAD_ERRLOG, %g3 ! and write back the updated 1500 stxa %g2, [%g3]ASI_SCRATCHPAD ! count into the errlog reg 1501 LOG_UGER_REG(%g1, %g2, %g3) ! Log the error info 1502 #ifdef TRAPTRACE 1503 OPL_TRAPTRACE(%g1, %g2, %g3, opl_uger_trap_lb) 1504 #endif /* TRAPTRACE */ 1505 retry ! retry - no ereport 1506 1507 /* 1508 * Process the rest of the unrecoverable error cases 1509 * All error cases below ultimately branch to either 1510 * opl_uger_panic or opl_uger_panic1. 1511 * opl_uger_panic1 is the same as opl_uger_panic except 1512 * for the additional execution of the RESET_TO_PRIV() 1513 * macro that does a heavy handed reset. Read the 1514 * comments for RESET_TO_PRIV() macro for more info. 1515 */ 1516 opl_uger_cre: 1517 set UGESR_IAUG_CRE, %g2 1518 andcc %g1, %g2, %g0 1519 bz,pt %xcc, opl_uger_ctxt 1520 nop 1521 IAG_CRE(%g2, %g3) 1522 set AFSR_ECR, %g2 1523 ldxa [%g2]ASI_AFSR, %g3 1524 or %g3, ASI_ECR_WEAK_ED, %g3 1525 stxa %g3, [%g2]ASI_AFSR 1526 ba %xcc, opl_uger_panic 1527 nop 1528 1529 opl_uger_ctxt: 1530 set UGESR_IAUG_TSBCTXT, %g2 1531 andcc %g1, %g2, %g0 1532 bz,pt %xcc, opl_uger_tsbp 1533 nop 1534 GET_CPU_IMPL(%g2) 1535 cmp %g2, JUPITER_IMPL 1536 bne %xcc, 1f 1537 nop 1538 RESET_SHARED_CTXT(%g2) 1539 1: 1540 RESET_MMU_REGS(%g2, %g3, %g4) 1541 ba %xcc, opl_uger_panic 1542 nop 1543 1544 opl_uger_tsbp: 1545 set UGESR_IUG_TSBP, %g2 1546 andcc %g1, %g2, %g0 1547 bz,pt %xcc, opl_uger_pstate 1548 nop 1549 GET_CPU_IMPL(%g2) 1550 cmp %g2, JUPITER_IMPL 1551 bne %xcc, 1f 1552 nop 1553 RESET_TSB_PREFETCH(%g2) 1554 1: 1555 RESET_TSB_TAGPTR(%g2) 1556 1557 /* 1558 * IUG_TSBP error may corrupt MMU registers 1559 * Reset them here. 1560 */ 1561 RESET_MMU_REGS(%g2, %g3, %g4) 1562 ba %xcc, opl_uger_panic 1563 nop 1564 1565 opl_uger_pstate: 1566 set UGESR_IUG_PSTATE, %g2 1567 andcc %g1, %g2, %g0 1568 bz,pt %xcc, opl_uger_tstate 1569 nop 1570 RESET_CUR_TSTATE(%g2) 1571 ba %xcc, opl_uger_panic1 1572 nop 1573 1574 opl_uger_tstate: 1575 set UGESR_IUG_TSTATE, %g2 1576 andcc %g1, %g2, %g0 1577 bz,pt %xcc, opl_uger_f 1578 nop 1579 RESET_PREV_TSTATE(%g2, %g3, opl_uger_tstate_1) 1580 ba %xcc, opl_uger_panic1 1581 nop 1582 1583 opl_uger_f: 1584 set UGESR_IUG_F, %g2 1585 andcc %g1, %g2, %g0 1586 bz,pt %xcc, opl_uger_r 1587 nop 1588 CLEAR_FPREGS(%g2) 1589 ba %xcc, opl_uger_panic 1590 nop 1591 1592 opl_uger_r: 1593 set UGESR_IUG_R, %g2 1594 andcc %g1, %g2, %g0 1595 bz,pt %xcc, opl_uger_panic1 1596 nop 1597 CLEAR_GEN_REGS(%g2, opl_uger_r_1) 1598 ba %xcc, opl_uger_panic1 1599 nop 1600 1601 opl_uger_panic: 1602 mov %g1, %g2 ! %g2 = arg #1 1603 LOG_UGER_REG(%g1, %g3, %g4) 1604 ba %xcc, opl_uger_panic_cmn 1605 nop 1606 1607 opl_uger_panic1: 1608 mov %g1, %g2 ! %g2 = arg #1 1609 LOG_UGER_REG(%g1, %g3, %g4) 1610 RESET_TO_PRIV(%g1, %g3, %g4, %l0) 1611 1612 /* 1613 * Set up the argument for sys_trap. 1614 * %g2 = arg #1 already set above 1615 */ 1616 opl_uger_panic_cmn: 1617 RESET_USER_RTT_REGS(%g4, %g5, opl_uger_panic_resetskip) 1618 opl_uger_panic_resetskip: 1619 rdpr %tl, %g3 ! arg #2 1620 set opl_cpu_urgent_error, %g1 ! pc 1621 sethi %hi(sys_trap), %g5 1622 jmp %g5 + %lo(sys_trap) 1623 mov PIL_15, %g4 1624 SET_SIZE(opl_uger_trap) 1625 #endif /* lint */ 1626 1627 #if defined(lint) 1628 void 1629 opl_ta3_trap(void) 1630 {} 1631 void 1632 opl_cleanw_subr(void) 1633 {} 1634 #else /* lint */ 1635 /* 1636 * OPL ta3 support (note please, that win_reg 1637 * area size for each cpu is 2^7 bytes) 1638 */ 1639 1640 #define RESTORE_WREGS(tmp1, tmp2) \ 1641 CPU_INDEX(tmp1, tmp2) ;\ 1642 sethi %hi(opl_ta3_save), tmp2 ;\ 1643 ldx [tmp2 +%lo(opl_ta3_save)], tmp2 ;\ 1644 sllx tmp1, 7, tmp1 ;\ 1645 add tmp2, tmp1, tmp2 ;\ 1646 ldx [tmp2 + 0], %l0 ;\ 1647 ldx [tmp2 + 8], %l1 ;\ 1648 ldx [tmp2 + 16], %l2 ;\ 1649 ldx [tmp2 + 24], %l3 ;\ 1650 ldx [tmp2 + 32], %l4 ;\ 1651 ldx [tmp2 + 40], %l5 ;\ 1652 ldx [tmp2 + 48], %l6 ;\ 1653 ldx [tmp2 + 56], %l7 ;\ 1654 ldx [tmp2 + 64], %i0 ;\ 1655 ldx [tmp2 + 72], %i1 ;\ 1656 ldx [tmp2 + 80], %i2 ;\ 1657 ldx [tmp2 + 88], %i3 ;\ 1658 ldx [tmp2 + 96], %i4 ;\ 1659 ldx [tmp2 + 104], %i5 ;\ 1660 ldx [tmp2 + 112], %i6 ;\ 1661 ldx [tmp2 + 120], %i7 1662 1663 #define SAVE_WREGS(tmp1, tmp2) \ 1664 CPU_INDEX(tmp1, tmp2) ;\ 1665 sethi %hi(opl_ta3_save), tmp2 ;\ 1666 ldx [tmp2 +%lo(opl_ta3_save)], tmp2 ;\ 1667 sllx tmp1, 7, tmp1 ;\ 1668 add tmp2, tmp1, tmp2 ;\ 1669 stx %l0, [tmp2 + 0] ;\ 1670 stx %l1, [tmp2 + 8] ;\ 1671 stx %l2, [tmp2 + 16] ;\ 1672 stx %l3, [tmp2 + 24] ;\ 1673 stx %l4, [tmp2 + 32] ;\ 1674 stx %l5, [tmp2 + 40] ;\ 1675 stx %l6, [tmp2 + 48] ;\ 1676 stx %l7, [tmp2 + 56] ;\ 1677 stx %i0, [tmp2 + 64] ;\ 1678 stx %i1, [tmp2 + 72] ;\ 1679 stx %i2, [tmp2 + 80] ;\ 1680 stx %i3, [tmp2 + 88] ;\ 1681 stx %i4, [tmp2 + 96] ;\ 1682 stx %i5, [tmp2 + 104] ;\ 1683 stx %i6, [tmp2 + 112] ;\ 1684 stx %i7, [tmp2 + 120] 1685 1686 1687 /* 1688 * The purpose of this function is to make sure that the restore 1689 * instruction after the flushw does not cause a fill trap. The sun4u 1690 * fill trap handler can not handle a tlb fault of an unmapped stack 1691 * except at the restore instruction at user_rtt. On OPL systems the 1692 * stack can get unmapped between the flushw and restore instructions 1693 * since multiple strands share the tlb. 1694 */ 1695 ENTRY_NP(opl_ta3_trap) 1696 set trap, %g1 1697 mov T_FLUSHW, %g3 1698 sub %g0, 1, %g4 1699 rdpr %cwp, %g5 1700 SAVE_WREGS(%g2, %g6) 1701 save 1702 flushw 1703 rdpr %cwp, %g6 1704 wrpr %g5, %cwp 1705 RESTORE_WREGS(%g2, %g5) 1706 wrpr %g6, %cwp 1707 restored 1708 restore 1709 1710 ba,a fast_trap_done 1711 SET_SIZE(opl_ta3_trap) 1712 1713 ENTRY_NP(opl_cleanw_subr) 1714 set trap, %g1 1715 mov T_FLUSHW, %g3 1716 sub %g0, 1, %g4 1717 rdpr %cwp, %g5 1718 SAVE_WREGS(%g2, %g6) 1719 save 1720 flushw 1721 rdpr %cwp, %g6 1722 wrpr %g5, %cwp 1723 RESTORE_WREGS(%g2, %g5) 1724 wrpr %g6, %cwp 1725 restored 1726 restore 1727 jmp %g7 1728 nop 1729 SET_SIZE(opl_cleanw_subr) 1730 #endif /* lint */ 1731 1732 #if defined(lint) 1733 1734 void 1735 opl_serr_instr(void) 1736 {} 1737 1738 #else /* lint */ 1739 /* 1740 * The actual trap handler for tt=0x0a, and tt=0x32 1741 */ 1742 ENTRY_NP(opl_serr_instr) 1743 OPL_SAVE_GLOBAL(%g1,%g2,%g3) 1744 sethi %hi(opl_sync_trap), %g3 1745 jmp %g3 + %lo(opl_sync_trap) 1746 rdpr %tt, %g1 1747 .align 32 1748 SET_SIZE(opl_serr_instr) 1749 1750 #endif /* lint */ 1751 1752 #if defined(lint) 1753 1754 void 1755 opl_ugerr_instr(void) 1756 {} 1757 1758 #else /* lint */ 1759 /* 1760 * The actual trap handler for tt=0x40 1761 */ 1762 ENTRY_NP(opl_ugerr_instr) 1763 sethi %hi(opl_uger_trap), %g3 1764 jmp %g3 + %lo(opl_uger_trap) 1765 nop 1766 .align 32 1767 SET_SIZE(opl_ugerr_instr) 1768 1769 #endif /* lint */ 1770 1771 #if defined(lint) 1772 1773 void 1774 opl_ta3_instr(void) 1775 {} 1776 1777 #else /* lint */ 1778 /* 1779 * The actual trap handler for tt=0x103 (flushw) 1780 */ 1781 ENTRY_NP(opl_ta3_instr) 1782 sethi %hi(opl_ta3_trap), %g3 1783 jmp %g3 + %lo(opl_ta3_trap) 1784 nop 1785 .align 32 1786 SET_SIZE(opl_ta3_instr) 1787 1788 #endif /* lint */ 1789 1790 #if defined(lint) 1791 1792 void 1793 opl_ta4_instr(void) 1794 {} 1795 1796 #else /* lint */ 1797 /* 1798 * The patch for the .clean_windows code 1799 */ 1800 ENTRY_NP(opl_ta4_instr) 1801 sethi %hi(opl_cleanw_subr), %g3 1802 add %g3, %lo(opl_cleanw_subr), %g3 1803 jmpl %g3, %g7 1804 add %g7, 8, %g7 1805 nop 1806 nop 1807 nop 1808 SET_SIZE(opl_ta4_instr) 1809 1810 #endif /* lint */ 1811 1812 #if defined(lint) 1813 /* 1814 * Get timestamp (stick). 1815 */ 1816 /* ARGSUSED */ 1817 void 1818 stick_timestamp(int64_t *ts) 1819 { 1820 } 1821 1822 #else /* lint */ 1823 1824 ENTRY_NP(stick_timestamp) 1825 rd STICK, %g1 ! read stick reg 1826 sllx %g1, 1, %g1 1827 srlx %g1, 1, %g1 ! clear npt bit 1828 1829 retl 1830 stx %g1, [%o0] ! store the timestamp 1831 SET_SIZE(stick_timestamp) 1832 1833 #endif /* lint */ 1834 1835 1836 #if defined(lint) 1837 /* 1838 * Set STICK adjusted by skew. 1839 */ 1840 /* ARGSUSED */ 1841 void 1842 stick_adj(int64_t skew) 1843 { 1844 } 1845 1846 #else /* lint */ 1847 1848 ENTRY_NP(stick_adj) 1849 rdpr %pstate, %g1 ! save processor state 1850 andn %g1, PSTATE_IE, %g3 1851 ba 1f ! cache align stick adj 1852 wrpr %g0, %g3, %pstate ! turn off interrupts 1853 1854 .align 16 1855 1: nop 1856 1857 rd STICK, %g4 ! read stick reg 1858 add %g4, %o0, %o1 ! adjust stick with skew 1859 wr %o1, %g0, STICK ! write stick reg 1860 1861 retl 1862 wrpr %g1, %pstate ! restore processor state 1863 SET_SIZE(stick_adj) 1864 1865 #endif /* lint */ 1866 1867 #if defined(lint) 1868 /* 1869 * Debugger-specific stick retrieval 1870 */ 1871 /*ARGSUSED*/ 1872 int 1873 kdi_get_stick(uint64_t *stickp) 1874 { 1875 return (0); 1876 } 1877 1878 #else /* lint */ 1879 1880 ENTRY_NP(kdi_get_stick) 1881 rd STICK, %g1 1882 stx %g1, [%o0] 1883 retl 1884 mov %g0, %o0 1885 SET_SIZE(kdi_get_stick) 1886 1887 #endif /* lint */ 1888 1889 #if defined(lint) 1890 1891 /*ARGSUSED*/ 1892 int 1893 dtrace_blksuword32(uintptr_t addr, uint32_t *data, int tryagain) 1894 { return (0); } 1895 1896 #else 1897 1898 ENTRY(dtrace_blksuword32) 1899 save %sp, -SA(MINFRAME + 4), %sp 1900 1901 rdpr %pstate, %l1 1902 andn %l1, PSTATE_IE, %l2 ! disable interrupts to 1903 wrpr %g0, %l2, %pstate ! protect our FPU diddling 1904 1905 rd %fprs, %l0 1906 andcc %l0, FPRS_FEF, %g0 1907 bz,a,pt %xcc, 1f ! if the fpu is disabled 1908 wr %g0, FPRS_FEF, %fprs ! ... enable the fpu 1909 1910 st %f0, [%fp + STACK_BIAS - 4] ! save %f0 to the stack 1911 1: 1912 set 0f, %l5 1913 /* 1914 * We're about to write a block full or either total garbage 1915 * (not kernel data, don't worry) or user floating-point data 1916 * (so it only _looks_ like garbage). 1917 */ 1918 ld [%i1], %f0 ! modify the block 1919 membar #Sync 1920 stn %l5, [THREAD_REG + T_LOFAULT] ! set up the lofault handler 1921 stda %d0, [%i0]ASI_BLK_COMMIT_S ! store the modified block 1922 membar #Sync 1923 flush %i0 ! flush instruction pipeline 1924 stn %g0, [THREAD_REG + T_LOFAULT] ! remove the lofault handler 1925 1926 bz,a,pt %xcc, 1f 1927 wr %g0, %l0, %fprs ! restore %fprs 1928 1929 ld [%fp + STACK_BIAS - 4], %f0 ! restore %f0 1930 1: 1931 1932 wrpr %g0, %l1, %pstate ! restore interrupts 1933 1934 ret 1935 restore %g0, %g0, %o0 1936 1937 0: 1938 membar #Sync 1939 stn %g0, [THREAD_REG + T_LOFAULT] ! remove the lofault handler 1940 1941 bz,a,pt %xcc, 1f 1942 wr %g0, %l0, %fprs ! restore %fprs 1943 1944 ld [%fp + STACK_BIAS - 4], %f0 ! restore %f0 1945 1: 1946 1947 wrpr %g0, %l1, %pstate ! restore interrupts 1948 1949 /* 1950 * If tryagain is set (%i2) we tail-call dtrace_blksuword32_err() 1951 * which deals with watchpoints. Otherwise, just return -1. 1952 */ 1953 brnz,pt %i2, 1f 1954 nop 1955 ret 1956 restore %g0, -1, %o0 1957 1: 1958 call dtrace_blksuword32_err 1959 restore 1960 1961 SET_SIZE(dtrace_blksuword32) 1962 #endif /* lint */ 1963 1964 #if defined(lint) 1965 /*ARGSUSED*/ 1966 void 1967 ras_cntr_reset(void *arg) 1968 { 1969 } 1970 #else 1971 ENTRY_NP(ras_cntr_reset) 1972 set OPL_SCRATCHPAD_ERRLOG, %o1 1973 ldxa [%o1]ASI_SCRATCHPAD, %o0 1974 or %o0, ERRLOG_REG_NUMERR_MASK, %o0 1975 retl 1976 stxa %o0, [%o1]ASI_SCRATCHPAD 1977 SET_SIZE(ras_cntr_reset) 1978 #endif /* lint */ 1979 1980 #if defined(lint) 1981 /* ARGSUSED */ 1982 void 1983 opl_error_setup(uint64_t cpu_err_log_pa) 1984 { 1985 } 1986 1987 #else /* lint */ 1988 ENTRY_NP(opl_error_setup) 1989 /* 1990 * Initialize the error log scratchpad register 1991 */ 1992 ldxa [%g0]ASI_EIDR, %o2 1993 sethi %hi(ERRLOG_REG_EIDR_MASK), %o1 1994 or %o1, %lo(ERRLOG_REG_EIDR_MASK), %o1 1995 and %o2, %o1, %o3 1996 sllx %o3, ERRLOG_REG_EIDR_SHIFT, %o2 1997 or %o2, %o0, %o3 1998 or %o3, ERRLOG_REG_NUMERR_MASK, %o0 1999 set OPL_SCRATCHPAD_ERRLOG, %o1 2000 stxa %o0, [%o1]ASI_SCRATCHPAD 2001 /* 2002 * Disable all restrainable error traps 2003 */ 2004 mov AFSR_ECR, %o1 2005 ldxa [%o1]ASI_AFSR, %o0 2006 andn %o0, ASI_ECR_RTE_UE|ASI_ECR_RTE_CEDG, %o0 2007 retl 2008 stxa %o0, [%o1]ASI_AFSR 2009 SET_SIZE(opl_error_setup) 2010 #endif /* lint */ 2011 2012 #if defined(lint) 2013 /* ARGSUSED */ 2014 void 2015 cpu_early_feature_init(void) 2016 { 2017 } 2018 #else /* lint */ 2019 ENTRY_NP(cpu_early_feature_init) 2020 /* 2021 * Enable MMU translating multiple page sizes for 2022 * sITLB and sDTLB. 2023 */ 2024 mov LSU_MCNTL, %o0 2025 ldxa [%o0] ASI_MCNTL, %o1 2026 or %o1, MCNTL_MPG_SITLB | MCNTL_MPG_SDTLB, %o1 2027 stxa %o1, [%o0] ASI_MCNTL 2028 /* 2029 * Demap all previous entries. 2030 */ 2031 sethi %hi(FLUSH_ADDR), %o1 2032 set DEMAP_ALL_TYPE, %o0 2033 stxa %g0, [%o0]ASI_DTLB_DEMAP 2034 stxa %g0, [%o0]ASI_ITLB_DEMAP 2035 retl 2036 flush %o1 2037 SET_SIZE(cpu_early_feature_init) 2038 #endif /* lint */ 2039 2040 #if defined(lint) 2041 /* 2042 * This function is called for each (enabled) CPU. We use it to 2043 * initialize error handling related registers. 2044 */ 2045 /*ARGSUSED*/ 2046 void 2047 cpu_feature_init(void) 2048 {} 2049 #else /* lint */ 2050 ENTRY(cpu_feature_init) 2051 ! 2052 ! get the device_id and store the device_id 2053 ! in the appropriate cpunodes structure 2054 ! given the cpus index 2055 ! 2056 CPU_INDEX(%o0, %o1) 2057 mulx %o0, CPU_NODE_SIZE, %o0 2058 set cpunodes + DEVICE_ID, %o1 2059 ldxa [%g0] ASI_DEVICE_SERIAL_ID, %o2 2060 stx %o2, [%o0 + %o1] 2061 ! 2062 ! initialize CPU registers 2063 ! 2064 ba opl_cpu_reg_init 2065 nop 2066 SET_SIZE(cpu_feature_init) 2067 #endif /* lint */ 2068 2069 #if defined(lint) 2070 2071 void 2072 cpu_cleartickpnt(void) 2073 {} 2074 2075 #else /* lint */ 2076 /* 2077 * Clear the NPT (non-privileged trap) bit in the %tick/%stick 2078 * registers. In an effort to make the change in the 2079 * tick/stick counter as consistent as possible, we disable 2080 * all interrupts while we're changing the registers. We also 2081 * ensure that the read and write instructions are in the same 2082 * line in the instruction cache. 2083 */ 2084 ENTRY_NP(cpu_clearticknpt) 2085 rdpr %pstate, %g1 /* save processor state */ 2086 andn %g1, PSTATE_IE, %g3 /* turn off */ 2087 wrpr %g0, %g3, %pstate /* interrupts */ 2088 rdpr %tick, %g2 /* get tick register */ 2089 brgez,pn %g2, 1f /* if NPT bit off, we're done */ 2090 mov 1, %g3 /* create mask */ 2091 sllx %g3, 63, %g3 /* for NPT bit */ 2092 ba,a,pt %xcc, 2f 2093 .align 8 /* Ensure rd/wr in same i$ line */ 2094 2: 2095 rdpr %tick, %g2 /* get tick register */ 2096 wrpr %g3, %g2, %tick /* write tick register, */ 2097 /* clearing NPT bit */ 2098 1: 2099 rd STICK, %g2 /* get stick register */ 2100 brgez,pn %g2, 3f /* if NPT bit off, we're done */ 2101 mov 1, %g3 /* create mask */ 2102 sllx %g3, 63, %g3 /* for NPT bit */ 2103 ba,a,pt %xcc, 4f 2104 .align 8 /* Ensure rd/wr in same i$ line */ 2105 4: 2106 rd STICK, %g2 /* get stick register */ 2107 wr %g3, %g2, STICK /* write stick register, */ 2108 /* clearing NPT bit */ 2109 3: 2110 jmp %g4 + 4 2111 wrpr %g0, %g1, %pstate /* restore processor state */ 2112 2113 SET_SIZE(cpu_clearticknpt) 2114 2115 #endif /* lint */ 2116 2117 #if defined(lint) 2118 2119 void 2120 cpu_halt_cpu(void) 2121 {} 2122 2123 void 2124 cpu_smt_pause(void) 2125 {} 2126 2127 #else /* lint */ 2128 2129 /* 2130 * Halt the current strand with the suspend instruction. 2131 * The compiler/asm currently does not support this suspend 2132 * instruction mnemonic, use byte code for now. 2133 */ 2134 ENTRY_NP(cpu_halt_cpu) 2135 .word 0x81b01040 2136 retl 2137 nop 2138 SET_SIZE(cpu_halt_cpu) 2139 2140 /* 2141 * Pause the current strand with the sleep instruction. 2142 * The compiler/asm currently does not support this sleep 2143 * instruction mnemonic, use byte code for now. 2144 */ 2145 ENTRY_NP(cpu_smt_pause) 2146 .word 0x81b01060 2147 retl 2148 nop 2149 SET_SIZE(cpu_smt_pause) 2150 2151 #endif /* lint */ 2152
Indexes created Wed Feb 10 08:45:31 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
