locore.s revision 1.11
1 /* $NetBSD: locore.s,v 1.11 1997/03/13 20:46:37 gwr Exp $ */ 2 3 /* 4 * Copyright (c) 1988 University of Utah. 5 * Copyright (c) 1980, 1990, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by 9 * the Systems Programming Group of the University of Utah Computer 10 * Science Department. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by the University of 23 * California, Berkeley and its contributors. 24 * 4. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * from: Utah $Hdr: locore.s 1.66 92/12/22$ 41 * @(#)locore.s 8.6 (Berkeley) 5/27/94 42 */ 43 44 #include "assym.h" 45 #include <machine/trap.h> 46 47 | Remember this is a fun project! 48 49 .data 50 .globl _mon_crp 51 _mon_crp: 52 .long 0,0 53 54 | This is for kvm_mkdb, and should be the address of the beginning 55 | of the kernel text segment (not necessarily the same as kernbase). 56 .text 57 .globl _kernel_text 58 _kernel_text: 59 60 | This is the entry point, as well as the end of the temporary stack 61 | used during process switch (one 8K page ending at start) 62 .globl tmpstk 63 tmpstk: 64 .globl start 65 start: 66 | The first step, after disabling interrupts, is to map enough of the kernel 67 | into high virtual address space so that we can use position dependent code. 68 | This is a tricky task on the sun3x because the MMU is already enabled and 69 | the ROM monitor provides no indication of where the root MMU table is mapped. 70 | Therefore we must use one of the 68030's 'transparent translation' registers 71 | to define a range in the address space where the MMU translation is 72 | turned off. Once this is complete we can modify the MMU table directly 73 | without the need for it to be mapped into virtual memory. 74 | All code must be position independent until otherwise noted, as the 75 | boot loader has loaded us into low memory but all the symbols in this 76 | code have been linked high. 77 movw #PSL_HIGHIPL, sr | no interrupts 78 movl #KERNBASE, a5 | for vtop conversion 79 lea _mon_crp, a0 | where to store the CRP 80 subl a5, a0 81 | Note: borrowing mon_crp for tt0 setup... 82 movl #0x3F8107, a0@ | map the low 1GB v=p with the 83 pmove a0@, tt0 | transparent translation reg0 84 85 | In order to map the kernel into high memory we will copy the root table 86 | entry which maps the 16 megabytes of memory starting at 0x0 into the 87 | entry which maps the 16 megabytes starting at KERNBASE. 88 pmove crp, a0@ | Get monitor CPU root pointer 89 movl a0@(4), a1 | 2nd word is PA of level A table 90 91 movl a1, a0 | compute the descriptor address 92 addl #0x3e0, a1 | for VA starting at KERNBASE 93 movl a0@, a1@ | copy descriptor type 94 movl a0@(4), a1@(4) | copy physical address 95 96 | Kernel is now double mapped at zero and KERNBASE. 97 | Force a long jump to the relocated code (high VA). 98 movl #IC_CLEAR, d0 | Flush the I-cache 99 movc d0, cacr 100 jmp L_high_code:l | long jump 101 102 L_high_code: 103 | We are now running in the correctly relocated kernel, so 104 | we are no longer restricted to position-independent code. 105 | It is handy to leave transparent translation enabled while 106 | for the low 1GB while __bootstrap() is doing its thing. 107 108 | Do bootstrap stuff needed before main() gets called. 109 | Our boot loader leaves a copy of the kernel's exec header 110 | just before the start of the kernel text segment, so the 111 | kernel can sanity-check the DDB symbols at [end...esym]. 112 | Pass the struct exec at tmpstk-32 to __bootstrap(). 113 | Also, make sure the initial frame pointer is zero so that 114 | the backtrace algorithm used by KGDB terminates nicely. 115 lea tmpstk-32, sp 116 movl #0,a6 117 jsr __bootstrap | See _startup.c 118 119 | Now turn off the transparent translation of the low 1GB. 120 | (this also flushes the ATC) 121 clrl sp@- 122 pmove sp@,tt0 123 addql #4,sp 124 125 | Now that __bootstrap() is done using the PROM functions, 126 | we can safely set the sfc/dfc to something != FC_CONTROL 127 moveq #FC_USERD, d0 | make movs access "user data" 128 movc d0, sfc | space for copyin/copyout 129 movc d0, dfc 130 131 | Setup process zero user/kernel stacks. 132 movl _proc0paddr,a1 | get proc0 pcb addr 133 lea a1@(USPACE-4),sp | set SSP to last word 134 movl #USRSTACK-4,a2 135 movl a2,usp | init user SP 136 137 | Note curpcb was already set in __bootstrap(). 138 | Will do fpu initialization during autoconfig (see fpu.c) 139 | The interrupt vector table and stack are now ready. 140 | Interrupts will be enabled later, AFTER autoconfiguration 141 | is finished, to avoid spurrious interrupts. 142 143 /* 144 * Final preparation for calling main. 145 * 146 * Create a fake exception frame that returns to user mode, 147 * and save its address in p->p_md.md_regs for cpu_fork(). 148 * The new frames for process 1 and 2 will be adjusted by 149 * cpu_set_kpc() to arrange for a call to a kernel function 150 * before the new process does its rte out to user mode. 151 */ 152 clrw sp@- | tf_format,tf_vector 153 clrl sp@- | tf_pc (filled in later) 154 movw #PSL_USER,sp@- | tf_sr for user mode 155 clrl sp@- | tf_stackadj 156 lea sp@(-64),sp | tf_regs[16] 157 movl sp,a1 | a1=trapframe 158 lea _proc0,a0 | proc0.p_md.md_regs = 159 movl a1,a0@(P_MDREGS) | trapframe 160 movl a2,a1@(FR_SP) | a2 == usp (from above) 161 pea a1@ | push &trapframe 162 jbsr _main | main(&trapframe) 163 addql #4,sp | help DDB backtrace 164 trap #15 | should not get here 165 166 | This is used by cpu_fork() to return to user mode. 167 | It is called with SP pointing to a struct trapframe. 168 .globl _proc_do_uret 169 _proc_do_uret: 170 movl sp@(FR_SP),a0 | grab and load 171 movl a0,usp | user SP 172 moveml sp@+,#0x7FFF | load most registers (all but SSP) 173 addql #8,sp | pop SSP and stack adjust count 174 rte 175 176 /* 177 * proc_trampoline: 178 * This is used by cpu_set_kpc() to "push" a function call onto the 179 * kernel stack of some process, very much like a signal delivery. 180 * When we get here, the stack has: 181 * 182 * SP+8: switchframe from before cpu_set_kpc 183 * SP+4: void *proc; 184 * SP: u_long func; 185 * 186 * On entry, the switchframe pushed by cpu_set_kpc has already been 187 * popped off the stack, so all this needs to do is pop the function 188 * pointer into a register, call it, then pop the arg, and finally 189 * return using the switchframe that remains on the stack. 190 */ 191 .globl _proc_trampoline 192 _proc_trampoline: 193 movl sp@+,a0 | function pointer 194 jbsr a0@ | (*func)(procp) 195 addql #4,sp | toss the arg 196 rts | as cpu_switch would do 197 198 | That is all the assembly startup code we need on the sun3x! 199 | The rest of this is like the hp300/locore.s where possible. 200 201 /* 202 * Trap/interrupt vector routines 203 */ 204 205 .globl _buserr, _addrerr, _illinst, _zerodiv, _chkinst 206 .globl _trapvinst, _privinst, _trace, _badtrap, _fmterr 207 .globl _trap0, _trap1, _trap2, _trap12, _trap15 208 .globl _coperr, _fpfline, _fpunsupp 209 210 .globl _trap, _nofault, _longjmp 211 _buserr: 212 tstl _nofault | device probe? 213 jeq _addrerr | no, handle as usual 214 movl _nofault,sp@- | yes, 215 jbsr _longjmp | longjmp(nofault) 216 _addrerr: 217 clrl sp@- | stack adjust count 218 moveml #0xFFFF,sp@- | save user registers 219 movl usp,a0 | save the user SP 220 movl a0,sp@(FR_SP) | in the savearea 221 lea sp@(FR_HW),a1 | grab base of HW berr frame 222 moveq #0,d0 223 movw a1@(10),d0 | grab SSW for fault processing 224 btst #12,d0 | RB set? 225 jeq LbeX0 | no, test RC 226 bset #14,d0 | yes, must set FB 227 movw d0,a1@(10) | for hardware too 228 LbeX0: 229 btst #13,d0 | RC set? 230 jeq LbeX1 | no, skip 231 bset #15,d0 | yes, must set FC 232 movw d0,a1@(10) | for hardware too 233 LbeX1: 234 btst #8,d0 | data fault? 235 jeq Lbe0 | no, check for hard cases 236 movl a1@(16),d1 | fault address is as given in frame 237 jra Lbe10 | thats it 238 Lbe0: 239 btst #4,a1@(6) | long (type B) stack frame? 240 jne Lbe4 | yes, go handle 241 movl a1@(2),d1 | no, can use save PC 242 btst #14,d0 | FB set? 243 jeq Lbe3 | no, try FC 244 addql #4,d1 | yes, adjust address 245 jra Lbe10 | done 246 Lbe3: 247 btst #15,d0 | FC set? 248 jeq Lbe10 | no, done 249 addql #2,d1 | yes, adjust address 250 jra Lbe10 | done 251 Lbe4: 252 movl a1@(36),d1 | long format, use stage B address 253 btst #15,d0 | FC set? 254 jeq Lbe10 | no, all done 255 subql #2,d1 | yes, adjust address 256 Lbe10: 257 movl d1,sp@- | push fault VA 258 movl d0,sp@- | and padded SSW 259 movw a1@(6),d0 | get frame format/vector offset 260 andw #0x0FFF,d0 | clear out frame format 261 cmpw #12,d0 | address error vector? 262 jeq Lisaerr | yes, go to it 263 264 /* MMU-specific code to determine reason for bus error. */ 265 movl d1,a0 | fault address 266 movl sp@,d0 | function code from ssw 267 btst #8,d0 | data fault? 268 jne Lbe10a 269 movql #1,d0 | user program access FC 270 | (we dont separate data/program) 271 btst #5,a1@ | supervisor mode? 272 jeq Lbe10a | if no, done 273 movql #5,d0 | else supervisor program access 274 Lbe10a: 275 ptestr d0,a0@,#7 | do a table search 276 pmove psr,sp@ | save result 277 movb sp@,d1 278 btst #2,d1 | invalid? (incl. limit viol and berr) 279 jeq Lmightnotbemerr | no -> wp check 280 btst #7,d1 | is it MMU table berr? 281 jeq Lismerr | no, must be fast 282 jra Lisberr1 | real bus err needs not be fast 283 Lmightnotbemerr: 284 btst #3,d1 | write protect bit set? 285 jeq Lisberr1 | no, must be bus error 286 movl sp@,d0 | ssw into low word of d0 287 andw #0xc0,d0 | write protect is set on page: 288 cmpw #0x40,d0 | was it read cycle? 289 jeq Lisberr1 | yes, was not WPE, must be bus err 290 /* End of MMU-specific bus error code. */ 291 292 Lismerr: 293 movl #T_MMUFLT,sp@- | show that we are an MMU fault 294 jra Ltrapnstkadj | and deal with it 295 Lisaerr: 296 movl #T_ADDRERR,sp@- | mark address error 297 jra Ltrapnstkadj | and deal with it 298 Lisberr1: 299 clrw sp@ | re-clear pad word 300 Lisberr: 301 movl #T_BUSERR,sp@- | mark bus error 302 Ltrapnstkadj: 303 jbsr _trap | handle the error 304 lea sp@(12),sp | pop value args 305 movl sp@(FR_SP),a0 | restore user SP 306 movl a0,usp | from save area 307 movw sp@(FR_ADJ),d0 | need to adjust stack? 308 jne Lstkadj | yes, go to it 309 moveml sp@+,#0x7FFF | no, restore most user regs 310 addql #8,sp | toss SSP and stkadj 311 jra rei | all done 312 Lstkadj: 313 lea sp@(FR_HW),a1 | pointer to HW frame 314 addql #8,a1 | source pointer 315 movl a1,a0 | source 316 addw d0,a0 | + hole size = dest pointer 317 movl a1@-,a0@- | copy 318 movl a1@-,a0@- | 8 bytes 319 movl a0,sp@(FR_SP) | new SSP 320 moveml sp@+,#0x7FFF | restore user registers 321 movl sp@,sp | and our SP 322 jra rei | all done 323 324 /* 325 * FP exceptions. 326 */ 327 _fpfline: 328 clrl sp@- | stack adjust count 329 moveml #0xFFFF,sp@- | save registers 330 moveq #T_FPEMULI,d0 | denote as FP emulation trap 331 jra fault | do it 332 333 _fpunsupp: 334 clrl sp@- | stack adjust count 335 moveml #0xFFFF,sp@- | save registers 336 moveq #T_FPEMULD,d0 | denote as FP emulation trap 337 jra fault | do it 338 339 /* 340 * Handles all other FP coprocessor exceptions. 341 * Note that since some FP exceptions generate mid-instruction frames 342 * and may cause signal delivery, we need to test for stack adjustment 343 * after the trap call. 344 */ 345 .globl _fpfault 346 _fpfault: 347 clrl sp@- | stack adjust count 348 moveml #0xFFFF,sp@- | save user registers 349 movl usp,a0 | and save 350 movl a0,sp@(FR_SP) | the user stack pointer 351 clrl sp@- | no VA arg 352 movl _curpcb,a0 | current pcb 353 lea a0@(PCB_FPCTX),a0 | address of FP savearea 354 fsave a0@ | save state 355 tstb a0@ | null state frame? 356 jeq Lfptnull | yes, safe 357 clrw d0 | no, need to tweak BIU 358 movb a0@(1),d0 | get frame size 359 bset #3,a0@(0,d0:w) | set exc_pend bit of BIU 360 Lfptnull: 361 fmovem fpsr,sp@- | push fpsr as code argument 362 frestore a0@ | restore state 363 movl #T_FPERR,sp@- | push type arg 364 jra Ltrapnstkadj | call trap and deal with stack cleanup 365 366 /* 367 * Coprocessor and format errors can generate mid-instruction stack 368 * frames and cause signal delivery hence we need to check for potential 369 * stack adjustment. 370 */ 371 _coperr: 372 clrl sp@- | stack adjust count 373 moveml #0xFFFF,sp@- 374 movl usp,a0 | get and save 375 movl a0,sp@(FR_SP) | the user stack pointer 376 clrl sp@- | no VA arg 377 clrl sp@- | or code arg 378 movl #T_COPERR,sp@- | push trap type 379 jra Ltrapnstkadj | call trap and deal with stack adjustments 380 381 _fmterr: 382 clrl sp@- | stack adjust count 383 moveml #0xFFFF,sp@- 384 movl usp,a0 | get and save 385 movl a0,sp@(FR_SP) | the user stack pointer 386 clrl sp@- | no VA arg 387 clrl sp@- | or code arg 388 movl #T_FMTERR,sp@- | push trap type 389 jra Ltrapnstkadj | call trap and deal with stack adjustments 390 391 /* 392 * Other exceptions only cause four and six word stack frame and require 393 * no post-trap stack adjustment. 394 */ 395 _illinst: 396 clrl sp@- 397 moveml #0xFFFF,sp@- 398 moveq #T_ILLINST,d0 399 jra fault 400 401 _zerodiv: 402 clrl sp@- 403 moveml #0xFFFF,sp@- 404 moveq #T_ZERODIV,d0 405 jra fault 406 407 _chkinst: 408 clrl sp@- 409 moveml #0xFFFF,sp@- 410 moveq #T_CHKINST,d0 411 jra fault 412 413 _trapvinst: 414 clrl sp@- 415 moveml #0xFFFF,sp@- 416 moveq #T_TRAPVINST,d0 417 jra fault 418 419 _privinst: 420 clrl sp@- 421 moveml #0xFFFF,sp@- 422 moveq #T_PRIVINST,d0 423 jra fault 424 425 .globl fault 426 fault: 427 movl usp,a0 | get and save 428 movl a0,sp@(FR_SP) | the user stack pointer 429 clrl sp@- | no VA arg 430 clrl sp@- | or code arg 431 movl d0,sp@- | push trap type 432 jbsr _trap | handle trap 433 lea sp@(12),sp | pop value args 434 movl sp@(FR_SP),a0 | restore 435 movl a0,usp | user SP 436 moveml sp@+,#0x7FFF | restore most user regs 437 addql #8,sp | pop SP and stack adjust 438 jra rei | all done 439 440 .globl _straytrap 441 _badtrap: 442 clrl sp@- | stack adjust count 443 moveml #0xFFFF,sp@- | save std frame regs 444 jbsr _straytrap | report 445 moveml sp@+,#0xFFFF | restore regs 446 addql #4, sp | stack adjust count 447 jra rei | all done 448 449 /* 450 * Trap 0 is for system calls 451 */ 452 .globl _syscall 453 _trap0: 454 clrl sp@- | stack adjust count 455 moveml #0xFFFF,sp@- | save user registers 456 movl usp,a0 | save the user SP 457 movl a0,sp@(FR_SP) | in the savearea 458 movl d0,sp@- | push syscall number 459 jbsr _syscall | handle it 460 addql #4,sp | pop syscall arg 461 movl sp@(FR_SP),a0 | grab and restore 462 movl a0,usp | user SP 463 moveml sp@+,#0x7FFF | restore most registers 464 addql #8,sp | pop SP and stack adjust 465 jra rei | all done 466 467 /* 468 * Trap 1 action depends on the emulation type: 469 * NetBSD: sigreturn "syscall" 470 * HPUX: user breakpoint 471 */ 472 _trap1: 473 #if 0 /* COMPAT_HPUX */ 474 /* If process is HPUX, this is a user breakpoint. */ 475 jne _trap15 | HPUX user breakpoint 476 #endif 477 jra sigreturn | NetBSD 478 479 /* 480 * Trap 2 action depends on the emulation type: 481 * NetBSD: user breakpoint -- See XXX below... 482 * SunOS: cache flush 483 * HPUX: sigreturn 484 */ 485 _trap2: 486 #if 0 /* COMPAT_HPUX */ 487 /* If process is HPUX, this is a sigreturn call */ 488 jne sigreturn 489 #endif 490 jra _trap15 | NetBSD user breakpoint 491 | XXX - Make NetBSD use trap 15 for breakpoints? 492 | XXX - That way, we can allow this cache flush... 493 | XXX SunOS trap #2 (and NetBSD?) 494 | Flush on-chip cache (leave it enabled) 495 | movl #CACHE_CLR,d0 496 | movc d0,cacr 497 | rte 498 499 /* 500 * Trap 12 is the entry point for the cachectl "syscall" 501 * cachectl(command, addr, length) 502 * command in d0, addr in a1, length in d1 503 */ 504 .globl _cachectl 505 _trap12: 506 movl d1,sp@- | push length 507 movl a1,sp@- | push addr 508 movl d0,sp@- | push command 509 jbsr _cachectl | do it 510 lea sp@(12),sp | pop args 511 jra rei | all done 512 513 /* 514 * Trace (single-step) trap. Kernel-mode is special. 515 * User mode traps are simply passed on to trap(). 516 */ 517 _trace: 518 clrl sp@- | stack adjust count 519 moveml #0xFFFF,sp@- 520 moveq #T_TRACE,d0 521 btst #5,sp@(FR_HW) | was supervisor mode? 522 jne kbrkpt | yes, kernel brkpt 523 jra fault | no, user-mode fault 524 525 /* 526 * Trap 15 is used for: 527 * - GDB breakpoints (in user programs) 528 * - KGDB breakpoints (in the kernel) 529 * - trace traps for SUN binaries (not fully supported yet) 530 * User mode traps are simply passed to trap(). 531 */ 532 _trap15: 533 clrl sp@- | stack adjust count 534 moveml #0xFFFF,sp@- 535 moveq #T_TRAP15,d0 536 btst #5,sp@(FR_HW) | was supervisor mode? 537 jne kbrkpt | yes, kernel brkpt 538 jra fault | no, user-mode fault 539 540 kbrkpt: 541 | Kernel-mode breakpoint or trace trap. (d0=trap_type) 542 | Save the system sp rather than the user sp. 543 movw #PSL_HIGHIPL,sr | lock out interrupts 544 lea sp@(FR_SIZE),a6 | Save stack pointer 545 movl a6,sp@(FR_SP) | from before trap 546 547 | If we are not on tmpstk switch to it. 548 | (so debugger can change the stack pointer) 549 movl a6,d1 550 cmpl #tmpstk,d1 551 jls Lbrkpt2 | already on tmpstk 552 | Copy frame to the temporary stack 553 movl sp,a0 | a0=src 554 lea tmpstk-96,a1 | a1=dst 555 movl a1,sp | sp=new frame 556 moveq #FR_SIZE,d1 557 Lbrkpt1: 558 movl a0@+,a1@+ 559 subql #4,d1 560 bgt Lbrkpt1 561 562 Lbrkpt2: 563 | Call the trap handler for the kernel debugger. 564 | Do not call trap() to handle it, so that we can 565 | set breakpoints in trap() if we want. We know 566 | the trap type is either T_TRACE or T_BREAKPOINT. 567 movl d0,sp@- | push trap type 568 jbsr _trap_kdebug 569 addql #4,sp | pop args 570 571 | The stack pointer may have been modified, or 572 | data below it modified (by kgdb push call), 573 | so push the hardware frame at the current sp 574 | before restoring registers and returning. 575 movl sp@(FR_SP),a0 | modified sp 576 lea sp@(FR_SIZE),a1 | end of our frame 577 movl a1@-,a0@- | copy 2 longs with 578 movl a1@-,a0@- | ... predecrement 579 movl a0,sp@(FR_SP) | sp = h/w frame 580 moveml sp@+,#0x7FFF | restore all but sp 581 movl sp@,sp | ... and sp 582 rte | all done 583 584 /* Use common m68k sigreturn */ 585 #include <m68k/m68k/sigreturn.s> 586 587 /* 588 * Interrupt handlers. Most are auto-vectored, 589 * and hard-wired the same way on all sun3 models. 590 * Format in the stack is: 591 * d0,d1,a0,a1, sr, pc, vo 592 */ 593 594 #define INTERRUPT_SAVEREG \ 595 moveml #0xC0C0,sp@- 596 597 #define INTERRUPT_RESTORE \ 598 moveml sp@+,#0x0303 599 600 /* 601 * This is the common auto-vector interrupt handler, 602 * for which the CPU provides the vector=0x18+level. 603 * These are installed in the interrupt vector table. 604 */ 605 .align 2 606 .globl __isr_autovec, _isr_autovec 607 __isr_autovec: 608 INTERRUPT_SAVEREG 609 jbsr _isr_autovec 610 INTERRUPT_RESTORE 611 jra rei 612 613 /* clock: see clock.c */ 614 .align 2 615 .globl __isr_clock, _clock_intr 616 __isr_clock: 617 INTERRUPT_SAVEREG 618 jbsr _clock_intr 619 INTERRUPT_RESTORE 620 jra rei 621 622 | Handler for all vectored interrupts (i.e. VME interrupts) 623 .align 2 624 .globl __isr_vectored, _isr_vectored 625 __isr_vectored: 626 INTERRUPT_SAVEREG 627 jbsr _isr_vectored 628 INTERRUPT_RESTORE 629 jra rei 630 631 #undef INTERRUPT_SAVEREG 632 #undef INTERRUPT_RESTORE 633 634 /* interrupt counters (needed by vmstat) */ 635 .globl _intrcnt,_eintrcnt,_intrnames,_eintrnames 636 _intrnames: 637 .asciz "spur" | 0 638 .asciz "lev1" | 1 639 .asciz "lev2" | 2 640 .asciz "lev3" | 3 641 .asciz "lev4" | 4 642 .asciz "clock" | 5 643 .asciz "lev6" | 6 644 .asciz "nmi" | 7 645 _eintrnames: 646 647 .data 648 .even 649 _intrcnt: 650 .long 0,0,0,0,0,0,0,0,0,0 651 _eintrcnt: 652 .text 653 654 /* 655 * Emulation of VAX REI instruction. 656 * 657 * This code is (mostly) un-altered from the hp300 code, 658 * except that sun machines do not need a simulated SIR 659 * because they have a real software interrupt register. 660 * 661 * This code deals with checking for and servicing ASTs 662 * (profiling, scheduling) and software interrupts (network, softclock). 663 * We check for ASTs first, just like the VAX. To avoid excess overhead 664 * the T_ASTFLT handling code will also check for software interrupts so we 665 * do not have to do it here. After identifying that we need an AST we 666 * drop the IPL to allow device interrupts. 667 * 668 * This code is complicated by the fact that sendsig may have been called 669 * necessitating a stack cleanup. 670 */ 671 672 .globl _astpending 673 .globl rei 674 rei: 675 #ifdef DIAGNOSTIC 676 tstl _panicstr | have we paniced? 677 jne Ldorte | yes, do not make matters worse 678 #endif 679 tstl _astpending | AST pending? 680 jeq Ldorte | no, done 681 Lrei1: 682 btst #5,sp@ | yes, are we returning to user mode? 683 jne Ldorte | no, done 684 movw #PSL_LOWIPL,sr | lower SPL 685 clrl sp@- | stack adjust 686 moveml #0xFFFF,sp@- | save all registers 687 movl usp,a1 | including 688 movl a1,sp@(FR_SP) | the users SP 689 clrl sp@- | VA == none 690 clrl sp@- | code == none 691 movl #T_ASTFLT,sp@- | type == async system trap 692 jbsr _trap | go handle it 693 lea sp@(12),sp | pop value args 694 movl sp@(FR_SP),a0 | restore user SP 695 movl a0,usp | from save area 696 movw sp@(FR_ADJ),d0 | need to adjust stack? 697 jne Laststkadj | yes, go to it 698 moveml sp@+,#0x7FFF | no, restore most user regs 699 addql #8,sp | toss SP and stack adjust 700 rte | and do real RTE 701 Laststkadj: 702 lea sp@(FR_HW),a1 | pointer to HW frame 703 addql #8,a1 | source pointer 704 movl a1,a0 | source 705 addw d0,a0 | + hole size = dest pointer 706 movl a1@-,a0@- | copy 707 movl a1@-,a0@- | 8 bytes 708 movl a0,sp@(FR_SP) | new SSP 709 moveml sp@+,#0x7FFF | restore user registers 710 movl sp@,sp | and our SP 711 Ldorte: 712 rte | real return 713 714 /* 715 * Initialization is at the beginning of this file, because the 716 * kernel entry point needs to be at zero for compatibility with 717 * the Sun boot loader. This works on Sun machines because the 718 * interrupt vector table for reset is NOT at address zero. 719 * (The MMU has a "boot" bit that forces access to the PROM) 720 */ 721 722 /* 723 * Signal "trampoline" code (18 bytes). Invoked from RTE setup by sendsig(). 724 * 725 * Stack looks like: 726 * 727 * sp+0 -> signal number 728 * sp+4 signal specific code 729 * sp+8 pointer to signal context frame (scp) 730 * sp+12 address of handler 731 * sp+16 saved hardware state 732 * . 733 * . 734 * scp+0-> beginning of signal context frame 735 */ 736 .globl _sigcode, _esigcode 737 .data 738 .align 2 739 _sigcode: /* Found at address: 0x0DFFffdc */ 740 movl sp@(12),a0 | signal handler addr (4 bytes) 741 jsr a0@ | call signal handler (2 bytes) 742 addql #4,sp | pop signo (2 bytes) 743 trap #1 | special syscall entry (2 bytes) 744 movl d0,sp@(4) | save errno (4 bytes) 745 moveq #1,d0 | syscall == exit (2 bytes) 746 trap #0 | exit(errno) (2 bytes) 747 .align 2 748 _esigcode: 749 .text 750 751 /* XXX - hp300 still has icode here... */ 752 753 /* 754 * Primitives 755 */ 756 #include <machine/asm.h> 757 758 /* 759 * non-local gotos 760 */ 761 ENTRY(setjmp) 762 movl sp@(4),a0 | savearea pointer 763 moveml #0xFCFC,a0@ | save d2-d7/a2-a7 764 movl sp@,a0@(48) | and return address 765 moveq #0,d0 | return 0 766 rts 767 768 ENTRY(longjmp) 769 movl sp@(4),a0 770 moveml a0@+,#0xFCFC 771 movl a0@,sp@ 772 moveq #1,d0 773 rts 774 775 /* 776 * The following primitives manipulate the run queues. 777 * _whichqs tells which of the 32 queues _qs have processes in them. 778 * Setrunqueue puts processes into queues, Remrunqueue removes them 779 * from queues. The running process is on no queue, other processes 780 * are on a queue related to p->p_priority, divided by 4 actually to 781 * shrink the 0-127 range of priorities into the 32 available queues. 782 */ 783 784 .globl _whichqs,_qs,_cnt,_panic 785 .globl _curproc 786 .comm _want_resched,4 787 788 /* 789 * setrunqueue(p) 790 * 791 * Call should be made at splclock(), and p->p_stat should be SRUN 792 */ 793 ENTRY(setrunqueue) 794 movl sp@(4),a0 795 #ifdef DIAGNOSTIC 796 tstl a0@(P_BACK) 797 jne Lset1 798 tstl a0@(P_WCHAN) 799 jne Lset1 800 cmpb #SRUN,a0@(P_STAT) 801 jne Lset1 802 #endif 803 clrl d0 804 movb a0@(P_PRIORITY),d0 805 lsrb #2,d0 806 movl _whichqs,d1 807 bset d0,d1 808 movl d1,_whichqs 809 lslb #3,d0 810 addl #_qs,d0 811 movl d0,a0@(P_FORW) 812 movl d0,a1 813 movl a1@(P_BACK),a0@(P_BACK) 814 movl a0,a1@(P_BACK) 815 movl a0@(P_BACK),a1 816 movl a0,a1@(P_FORW) 817 rts 818 #ifdef DIAGNOSTIC 819 Lset1: 820 movl #Lset2,sp@- 821 jbsr _panic 822 Lset2: 823 .asciz "setrunqueue" 824 .even 825 #endif 826 827 /* 828 * remrunqueue(p) 829 * 830 * Call should be made at splclock(). 831 */ 832 ENTRY(remrunqueue) 833 movl sp@(4),a0 | proc *p 834 clrl d0 835 movb a0@(P_PRIORITY),d0 836 lsrb #2,d0 837 movl _whichqs,d1 838 bclr d0,d1 | if ((d1 & (1 << d0)) == 0) 839 jeq Lrem2 | panic (empty queue) 840 movl d1,_whichqs 841 movl a0@(P_FORW),a1 842 movl a0@(P_BACK),a1@(P_BACK) 843 movl a0@(P_BACK),a1 844 movl a0@(P_FORW),a1@(P_FORW) 845 movl #_qs,a1 846 movl d0,d1 847 lslb #3,d1 848 addl d1,a1 849 cmpl a1@(P_FORW),a1 850 jeq Lrem1 851 movl _whichqs,d1 852 bset d0,d1 853 movl d1,_whichqs 854 Lrem1: 855 clrl a0@(P_BACK) 856 rts 857 Lrem2: 858 movl #Lrem3,sp@- 859 jbsr _panic 860 Lrem3: 861 .asciz "remrunqueue" 862 .even 863 864 | Message for Lbadsw panic 865 Lsw0: 866 .asciz "cpu_switch" 867 .even 868 869 .globl _curpcb 870 .globl _masterpaddr | XXX compatibility (debuggers) 871 .data 872 _masterpaddr: | XXX compatibility (debuggers) 873 _curpcb: 874 .long 0 875 .comm nullpcb,SIZEOF_PCB 876 .text 877 878 /* 879 * At exit of a process, do a cpu_switch for the last time. 880 * Switch to a safe stack and PCB, and deallocate the process's resources. 881 * The ipl is high enough to prevent the memory from being reallocated. 882 */ 883 ENTRY(switch_exit) 884 movl sp@(4),a0 | struct proc *p 885 movl #nullpcb,_curpcb | save state into garbage pcb 886 lea tmpstk,sp | goto a tmp stack 887 movl a0,sp@- | pass proc ptr down 888 889 /* Free old process's u-area. */ 890 movl #USPACE,sp@- | size of u-area 891 movl a0@(P_ADDR),sp@- | address of process's u-area 892 movl _kernel_map,sp@- | map it was allocated in 893 jbsr _kmem_free | deallocate it 894 lea sp@(12),sp | pop args 895 896 jra _cpu_switch 897 898 /* 899 * When no processes are on the runq, cpu_switch() branches to idle 900 * to wait for something to come ready. 901 */ 902 .data 903 .globl _Idle_count 904 _Idle_count: 905 .long 0 906 .text 907 908 .globl Idle 909 Lidle: 910 stop #PSL_LOWIPL 911 Idle: 912 movw #PSL_HIGHIPL,sr 913 addql #1, _Idle_count 914 tstl _whichqs 915 jeq Lidle 916 movw #PSL_LOWIPL,sr 917 jra Lsw1 918 919 Lbadsw: 920 movl #Lsw0,sp@- 921 jbsr _panic 922 /*NOTREACHED*/ 923 924 /* 925 * cpu_switch() 926 * Hacked for sun3 927 * XXX - Arg 1 is a proc pointer (curproc) but this doesn't use it. 928 * XXX - Sould we use p->p_addr instead of curpcb? -gwr 929 */ 930 ENTRY(cpu_switch) 931 movl _curpcb,a1 | current pcb 932 movw sr,a1@(PCB_PS) | save sr before changing ipl 933 #ifdef notyet 934 movl _curproc,sp@- | remember last proc running 935 #endif 936 clrl _curproc 937 938 Lsw1: 939 /* 940 * Find the highest-priority queue that isn't empty, 941 * then take the first proc from that queue. 942 */ 943 clrl d0 944 lea _whichqs,a0 945 movl a0@,d1 946 Lswchk: 947 btst d0,d1 948 jne Lswfnd 949 addqb #1,d0 950 cmpb #32,d0 951 jne Lswchk 952 jra Idle 953 Lswfnd: 954 movw #PSL_HIGHIPL,sr | lock out interrupts 955 movl a0@,d1 | and check again... 956 bclr d0,d1 957 jeq Lsw1 | proc moved, rescan 958 movl d1,a0@ | update whichqs 959 moveq #1,d1 | double check for higher priority 960 lsll d0,d1 | process (which may have snuck in 961 subql #1,d1 | while we were finding this one) 962 andl a0@,d1 963 jeq Lswok | no one got in, continue 964 movl a0@,d1 965 bset d0,d1 | otherwise put this one back 966 movl d1,a0@ 967 jra Lsw1 | and rescan 968 Lswok: 969 movl d0,d1 970 lslb #3,d1 | convert queue number to index 971 addl #_qs,d1 | locate queue (q) 972 movl d1,a1 973 cmpl a1@(P_FORW),a1 | anyone on queue? 974 jeq Lbadsw | no, panic 975 movl a1@(P_FORW),a0 | p = q->p_forw 976 movl a0@(P_FORW),a1@(P_FORW) | q->p_forw = p->p_forw 977 movl a0@(P_FORW),a1 | q = p->p_forw 978 movl a0@(P_BACK),a1@(P_BACK) | q->p_back = p->p_back 979 cmpl a0@(P_FORW),d1 | anyone left on queue? 980 jeq Lsw2 | no, skip 981 movl _whichqs,d1 982 bset d0,d1 | yes, reset bit 983 movl d1,_whichqs 984 Lsw2: 985 movl a0,_curproc 986 clrl _want_resched 987 #ifdef notyet 988 movl sp@+,a1 | XXX - Make this work! 989 cmpl a0,a1 | switching to same proc? 990 jeq Lswdone | yes, skip save and restore 991 #endif 992 /* 993 * Save state of previous process in its pcb. 994 */ 995 movl _curpcb,a1 996 moveml #0xFCFC,a1@(PCB_REGS) | save non-scratch registers 997 movl usp,a2 | grab USP (a2 has been saved) 998 movl a2,a1@(PCB_USP) | and save it 999 1000 tstl _fpu_type | Do we have an fpu? 1001 jeq Lswnofpsave | No? Then don't try save. 1002 lea a1@(PCB_FPCTX),a2 | pointer to FP save area 1003 fsave a2@ | save FP state 1004 tstb a2@ | null state frame? 1005 jeq Lswnofpsave | yes, all done 1006 fmovem fp0-fp7,a2@(FPF_REGS) | save FP general regs 1007 fmovem fpcr/fpsr/fpi,a2@(FPF_FPCR) | save FP control regs 1008 Lswnofpsave: 1009 1010 /* 1011 * Now that we have saved all the registers that must be 1012 * preserved, we are free to use those registers until 1013 * we load the registers for the switched-to process. 1014 * In this section, keep: a0=curproc, a1=curpcb 1015 */ 1016 1017 #ifdef DIAGNOSTIC 1018 tstl a0@(P_WCHAN) 1019 jne Lbadsw 1020 cmpb #SRUN,a0@(P_STAT) 1021 jne Lbadsw 1022 #endif 1023 clrl a0@(P_BACK) | clear back link 1024 movl a0@(P_ADDR),a1 | get p_addr 1025 movl a1,_curpcb 1026 1027 /* 1028 * Load the new VM context (new MMU root pointer) 1029 */ 1030 movl a0@(P_VMSPACE),a2 | vm = p->p_vmspace 1031 #ifdef DIAGNOSTIC 1032 tstl a2 | map == VM_MAP_NULL? 1033 jeq Lbadsw | panic 1034 #endif 1035 #ifdef PMAP_DEBUG 1036 /* 1037 * Just call pmap_activate() for now. Later on, 1038 * use the in-line version below (for speed). 1039 */ 1040 lea a2@(VM_PMAP),a2 | pmap = &vmspace.vm_pmap 1041 pea a2@ | push pmap 1042 jbsr _pmap_activate | pmap_activate(pmap) 1043 addql #4,sp 1044 movl _curpcb,a1 | restore p_addr 1045 #else 1046 /* XXX - Later, use this inline version. */ 1047 /* Just load the new CPU Root Pointer (MMU) */ 1048 lea _kernel_crp, a3 | our CPU Root Ptr. (CRP) 1049 lea a2@(VM_PMAP),a2 | pmap = &vmspace.vm_pmap 1050 movl a2@(PM_A_PHYS),d0 | phys = pmap->pm_a_phys 1051 cmpl a3@(4),d0 | == kernel_crp.rp_addr ? 1052 jeq Lsame_mmuctx | skip loadcrp/flush 1053 /* OK, it is a new MMU context. Load it up. */ 1054 movl d0,a3@(4) 1055 movl #CACHE_CLR,d0 1056 movc d0,cacr | invalidate cache(s) 1057 pflusha | flush entire TLB 1058 pmove a3@,crp | load new user root pointer 1059 Lsame_mmuctx: 1060 #endif 1061 1062 /* 1063 * Reload the registers for the new process. 1064 * After this point we can only use d0,d1,a0,a1 1065 */ 1066 moveml a1@(PCB_REGS),#0xFCFC | reload registers 1067 movl a1@(PCB_USP),a0 1068 movl a0,usp | and USP 1069 1070 tstl _fpu_type | If we don't have an fpu, 1071 jeq Lres_skip | don't try to restore it. 1072 lea a1@(PCB_FPCTX),a0 | pointer to FP save area 1073 tstb a0@ | null state frame? 1074 jeq Lresfprest | yes, easy 1075 fmovem a0@(FPF_FPCR),fpcr/fpsr/fpi | restore FP control regs 1076 fmovem a0@(FPF_REGS),fp0-fp7 | restore FP general regs 1077 Lresfprest: 1078 frestore a0@ | restore state 1079 Lres_skip: 1080 movw a1@(PCB_PS),d0 | no, restore PS 1081 #ifdef DIAGNOSTIC 1082 btst #13,d0 | supervisor mode? 1083 jeq Lbadsw | no? panic! 1084 #endif 1085 movw d0,sr | OK, restore PS 1086 moveq #1,d0 | return 1 (for alternate returns) 1087 rts 1088 1089 /* 1090 * savectx(pcb) 1091 * Update pcb, saving current processor state. 1092 */ 1093 ENTRY(savectx) 1094 movl sp@(4),a1 1095 movw sr,a1@(PCB_PS) 1096 movl usp,a0 | grab USP 1097 movl a0,a1@(PCB_USP) | and save it 1098 moveml #0xFCFC,a1@(PCB_REGS) | save non-scratch registers 1099 1100 tstl _fpu_type | Do we have FPU? 1101 jeq Lsavedone | No? Then don't save state. 1102 lea a1@(PCB_FPCTX),a0 | pointer to FP save area 1103 fsave a0@ | save FP state 1104 tstb a0@ | null state frame? 1105 jeq Lsavedone | yes, all done 1106 fmovem fp0-fp7,a0@(FPF_REGS) | save FP general regs 1107 fmovem fpcr/fpsr/fpi,a0@(FPF_FPCR) | save FP control regs 1108 Lsavedone: 1109 moveq #0,d0 | return 0 1110 rts 1111 1112 /* suline() `040 only */ 1113 1114 #ifdef DEBUG 1115 .data 1116 .globl fulltflush, fullcflush 1117 fulltflush: 1118 .long 0 1119 fullcflush: 1120 .long 0 1121 .text 1122 #endif 1123 1124 /* 1125 * Invalidate entire TLB. 1126 */ 1127 ENTRY(TBIA) 1128 __TBIA: 1129 pflusha 1130 movl #DC_CLEAR,d0 1131 movc d0,cacr | invalidate on-chip d-cache 1132 rts 1133 1134 /* 1135 * Invalidate any TLB entry for given VA (TB Invalidate Single) 1136 */ 1137 ENTRY(TBIS) 1138 #ifdef DEBUG 1139 tstl fulltflush | being conservative? 1140 jne __TBIA | yes, flush entire TLB 1141 #endif 1142 movl sp@(4),a0 1143 pflush #0,#0,a0@ | flush address from both sides 1144 movl #DC_CLEAR,d0 1145 movc d0,cacr | invalidate on-chip data cache 1146 rts 1147 1148 /* 1149 * Invalidate supervisor side of TLB 1150 */ 1151 ENTRY(TBIAS) 1152 #ifdef DEBUG 1153 tstl fulltflush | being conservative? 1154 jne __TBIA | yes, flush everything 1155 #endif 1156 pflush #4,#4 | flush supervisor TLB entries 1157 movl #DC_CLEAR,d0 1158 movc d0,cacr | invalidate on-chip d-cache 1159 rts 1160 1161 /* 1162 * Invalidate user side of TLB 1163 */ 1164 ENTRY(TBIAU) 1165 #ifdef DEBUG 1166 tstl fulltflush | being conservative? 1167 jne __TBIA | yes, flush everything 1168 #endif 1169 pflush #0,#4 | flush user TLB entries 1170 movl #DC_CLEAR,d0 1171 movc d0,cacr | invalidate on-chip d-cache 1172 rts 1173 1174 /* 1175 * Invalidate instruction cache 1176 */ 1177 ENTRY(ICIA) 1178 movl #IC_CLEAR,d0 1179 movc d0,cacr | invalidate i-cache 1180 rts 1181 1182 /* 1183 * Invalidate data cache. 1184 * NOTE: we do not flush 68030 on-chip cache as there are no aliasing 1185 * problems with DC_WA. The only cases we have to worry about are context 1186 * switch and TLB changes, both of which are handled "in-line" in resume 1187 * and TBI*. 1188 */ 1189 ENTRY(DCIA) 1190 __DCIA: 1191 rts 1192 1193 ENTRY(DCIS) 1194 __DCIS: 1195 rts 1196 1197 /* 1198 * Invalidate data cache. 1199 */ 1200 ENTRY(DCIU) 1201 movl #DC_CLEAR,d0 1202 movc d0,cacr | invalidate on-chip d-cache 1203 rts 1204 1205 /* ICPL, ICPP, DCPL, DCPP, DCPA, DCFL, DCFP */ 1206 1207 ENTRY(PCIA) 1208 movl #DC_CLEAR,d0 1209 movc d0,cacr | invalidate on-chip d-cache 1210 rts 1211 1212 ENTRY(ecacheon) 1213 rts 1214 1215 ENTRY(ecacheoff) 1216 rts 1217 1218 /* 1219 * Get callers current SP value. 1220 * Note that simply taking the address of a local variable in a C function 1221 * doesn't work because callee saved registers may be outside the stack frame 1222 * defined by A6 (e.g. GCC generated code). 1223 * 1224 * [I don't think the ENTRY() macro will do the right thing with this -- glass] 1225 */ 1226 .globl _getsp 1227 _getsp: 1228 movl sp,d0 | get current SP 1229 addql #4,d0 | compensate for return address 1230 rts 1231 1232 ENTRY(getsfc) 1233 movc sfc,d0 1234 rts 1235 1236 ENTRY(getdfc) 1237 movc dfc,d0 1238 rts 1239 1240 ENTRY(getvbr) 1241 movc vbr, d0 1242 rts 1243 1244 ENTRY(setvbr) 1245 movl sp@(4), d0 1246 movc d0, vbr 1247 rts 1248 1249 /* 1250 * Load a new CPU Root Pointer (CRP) into the MMU. 1251 * void loadcrp(struct mmu_rootptr *); 1252 */ 1253 ENTRY(loadcrp) 1254 movl sp@(4),a0 | arg1: &CRP 1255 movl #CACHE_CLR,d0 1256 movc d0,cacr | invalidate cache(s) 1257 pflusha | flush entire TLB 1258 pmove a0@,crp | load new user root pointer 1259 rts 1260 1261 /* 1262 * Get the physical address of the PTE for a given VA. 1263 */ 1264 ENTRY(ptest_addr) 1265 movl sp@(4),a0 | VA 1266 ptestr #5,a0@,#7,a1 | a1 = addr of PTE 1267 movl a1,d0 1268 rts 1269 1270 /* 1271 * Set processor priority level calls. Most are implemented with 1272 * inline asm expansions. However, we need one instantiation here 1273 * in case some non-optimized code makes external references. 1274 * Most places will use the inlined function param.h supplies. 1275 */ 1276 1277 ENTRY(_spl) 1278 movl sp@(4),d1 1279 clrl d0 1280 movw sr,d0 1281 movw d1,sr 1282 rts 1283 1284 ENTRY(getsr) 1285 moveq #0, d0 1286 movw sr, d0 1287 rts 1288 1289 ENTRY(_insque) 1290 movw sr,d0 1291 movw #PSL_HIGHIPL,sr | atomic 1292 movl sp@(8),a0 | where to insert (after) 1293 movl sp@(4),a1 | element to insert (e) 1294 movl a0@,a1@ | e->next = after->next 1295 movl a0,a1@(4) | e->prev = after 1296 movl a1,a0@ | after->next = e 1297 movl a1@,a0 1298 movl a1,a0@(4) | e->next->prev = e 1299 movw d0,sr 1300 rts 1301 1302 ENTRY(_remque) 1303 movw sr,d0 1304 movw #PSL_HIGHIPL,sr | atomic 1305 movl sp@(4),a0 | element to remove (e) 1306 movl a0@,a1 1307 movl a0@(4),a0 1308 movl a0,a1@(4) | e->next->prev = e->prev 1309 movl a1,a0@ | e->prev->next = e->next 1310 movw d0,sr 1311 rts 1312 1313 /* 1314 * Save and restore 68881 state. 1315 */ 1316 ENTRY(m68881_save) 1317 movl sp@(4),a0 | save area pointer 1318 fsave a0@ | save state 1319 tstb a0@ | null state frame? 1320 jeq Lm68881sdone | yes, all done 1321 fmovem fp0-fp7,a0@(FPF_REGS) | save FP general regs 1322 fmovem fpcr/fpsr/fpi,a0@(FPF_FPCR) | save FP control regs 1323 Lm68881sdone: 1324 rts 1325 1326 ENTRY(m68881_restore) 1327 movl sp@(4),a0 | save area pointer 1328 tstb a0@ | null state frame? 1329 jeq Lm68881rdone | yes, easy 1330 fmovem a0@(FPF_FPCR),fpcr/fpsr/fpi | restore FP control regs 1331 fmovem a0@(FPF_REGS),fp0-fp7 | restore FP general regs 1332 Lm68881rdone: 1333 frestore a0@ | restore state 1334 rts 1335 1336 /* 1337 * _delay(unsigned N) 1338 * Delay for at least (N/256) microseconds. 1339 * This routine depends on the variable: delay_divisor 1340 * which should be set based on the CPU clock rate. 1341 * XXX: Currently this is set in sun3_startup.c based on the 1342 * XXX: CPU model but this should be determined at run time... 1343 */ 1344 .globl __delay 1345 __delay: 1346 | d0 = arg = (usecs << 8) 1347 movl sp@(4),d0 1348 | d1 = delay_divisor; 1349 movl _delay_divisor,d1 1350 L_delay: 1351 subl d1,d0 1352 jgt L_delay 1353 rts 1354 1355 1356 | Define some addresses, mostly so DDB can print useful info. 1357 .globl _kernbase 1358 .set _kernbase,KERNBASE 1359 .globl _dvma_base 1360 .set _dvma_base,DVMA_SPACE_START 1361 .globl _prom_start 1362 .set _prom_start,MONSTART 1363 .globl _prom_base 1364 .set _prom_base,PROM_BASE 1365 1366 |The end! 1367
Indexes created Tue Oct 14 15:09:51 GMT 2025