Return to l.s CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot

Annotation of lucent/sys/src/9/gnot/l.s, revision 1.1

1.1     ! root        1: #include "mem.h"
        !             2: 
        !             3: #define        DBMAGIC         0xBADC0C0A
        !             4: 
        !             5: /*
        !             6:  * Boot first processor
        !             7:  */
        !             8: TEXT   start(SB), $-4
        !             9: 
        !            10:        MOVW    $(SUPER|SPL(7)), SR
        !            11:        MOVL    $a6base(SB), A6
        !            12:        MOVL    $0, R0
        !            13:        MOVL    R0, CACR
        !            14:        MOVL    R0, TACADDR             /* zero tac counter (cause an intr?) */
        !            15: 
        !            16:        MOVL    $mach0(SB), A0
        !            17:        MOVL    A0, m(SB)
        !            18:        MOVL    $0, 0(A0)
        !            19:        MOVL    A0, A7
        !            20:        ADDL    $(MACHSIZE-4), A7       /* start stack under machine struct */
        !            21:        MOVL    $0, u(SB)
        !            22: 
        !            23:        MOVL    $vectors(SB), A0
        !            24:        MOVL    A0, VBR
        !            25: 
        !            26:        BSR     main(SB)
        !            27:        /* never returns */
        !            28: dead:
        !            29:        BRA     dead
        !            30: 
        !            31: /*
        !            32:  * Take first processor into user mode.  Leave enough room on the kernel stack
        !            33:  * for a full-sized Ureg (including long bus error format) to fit
        !            34:  *     - argument is stack pointer to user
        !            35:  */
        !            36: 
        !            37: TEXT   touser(SB), $0
        !            38: 
        !            39:        MOVL    usp+0(FP), A0
        !            40:        MOVL    $(USERADDR+BY2PG-UREGVARSZ), A7
        !            41:        MOVW    $0, -(A7)
        !            42:        MOVL    $(UTZERO+32), -(A7)     /* header is in text */
        !            43:        MOVW    $0, -(A7)
        !            44:        MOVL    A0, USP
        !            45:        MOVW    $(SUPER|SPL(0)), SR
        !            46:        MOVL    $8, R0
        !            47:        MOVL    R0, CACR
        !            48:        RTE
        !            49: 
        !            50: TEXT   firmware(SB), $0
        !            51: 
        !            52:        MOVL    $0x40000090, A0
        !            53:        JMP     (A0)
        !            54: 
        !            55: TEXT   splhi(SB), $0
        !            56: 
        !            57:        MOVL    m(SB), A0
        !            58:        MOVL    (A7), 4(A0)
        !            59:        MOVL    $0, R0
        !            60:        MOVW    SR, R0
        !            61:        MOVW    $(SUPER|SPL(7)), SR
        !            62:        RTS
        !            63: 
        !            64: TEXT   splduart(SB), $0
        !            65: 
        !            66:        MOVL    $0, R0
        !            67:        MOVW    SR, R0
        !            68:        MOVW    $(SUPER|SPL(5)), SR
        !            69:        RTS
        !            70: 
        !            71: TEXT   spllo(SB), $0
        !            72: 
        !            73:        MOVL    $0, R0
        !            74:        MOVW    SR, R0
        !            75:        MOVW    $(SUPER|SPL(0)), SR
        !            76:        RTS
        !            77: 
        !            78: TEXT   splx(SB), $0
        !            79: 
        !            80:        MOVL    sr+0(FP), R0
        !            81:        MOVW    R0, SR
        !            82:        RTS
        !            83: 
        !            84: TEXT   spldone(SB), $0
        !            85: 
        !            86:        RTS
        !            87: 
        !            88: TEXT   spl1(SB), $0
        !            89: 
        !            90:        MOVL    $0, R0
        !            91:        MOVW    SR, R0
        !            92:        MOVW    $(SUPER|SPL(1)), SR
        !            93:        RTS
        !            94: 
        !            95: TEXT   flushcpucache(SB), $0
        !            96: 
        !            97:        MOVL    $(CCLEAR|CENABLE), R0
        !            98:        MOVL    R0, CACR
        !            99:        RTS
        !           100: 
        !           101: TEXT   cacrtrap(SB), $0        /* user entry point to control cache, e.g. flush */
        !           102: 
        !           103:        MOVL    R0, CACR
        !           104:        RTE
        !           105: 
        !           106: TEXT   setlabel(SB), $0
        !           107: 
        !           108:        MOVL    sr+0(FP), A0
        !           109:        MOVL    A7, (A0)+               /* stack pointer */
        !           110:        MOVL    (A7), (A0)+             /* pc of caller */
        !           111:        MOVW    SR, (A0)+               /* status register */
        !           112:        CLRL    R0                      /* ret 0 => not returning */
        !           113:        RTS
        !           114: 
        !           115: TEXT   gotolabel(SB), $0
        !           116: 
        !           117:        MOVL    p+0(FP), A0
        !           118:        MOVW    $(SUPER|SPL(7)), SR
        !           119:        MOVL    (A0)+, A7               /* stack pointer */
        !           120:        MOVL    (A0)+, (A7)             /* pc; stuff into stack frame */
        !           121:        MOVW    (A0)+, R0               /* status register */
        !           122:        MOVW    R0, SR
        !           123:        MOVL    $1, R0                  /* ret 1 => returning */
        !           124:        RTS
        !           125: 
        !           126: /*
        !           127:  * Test and set, as a subroutine
        !           128:  */
        !           129: 
        !           130: TEXT   tas(SB), $0
        !           131: 
        !           132:        MOVL    $0, R0
        !           133:        MOVL    a+0(FP), A0
        !           134:        TAS     (A0)
        !           135:        BEQ     tas_1
        !           136:        MOVL    $1, R0
        !           137: tas_1:
        !           138:        RTS
        !           139: 
        !           140: /*
        !           141:  * Floating point
        !           142:  */
        !           143: 
        !           144: TEXT   fpsave(SB), $0
        !           145: 
        !           146:        FSAVE   (fp+0(FP))
        !           147:        RTS
        !           148: 
        !           149: TEXT   fprestore(SB), $0
        !           150: 
        !           151:        FRESTORE        (fp+0(FP))
        !           152:        RTS
        !           153: 
        !           154: TEXT   fpregsave(SB), $0
        !           155: 
        !           156:        FMOVEM  $0xFF, (3*4)(fr+0(FP))
        !           157:        FMOVEMC $0x7, (fr+0(FP))
        !           158:        RTS
        !           159: 
        !           160: TEXT   fpregrestore(SB), $0
        !           161: 
        !           162:        FMOVEMC (fr+0(FP)), $0x7
        !           163:        FMOVEM  (3*4)(fr+0(FP)), $0xFF
        !           164:        RTS
        !           165: 
        !           166: TEXT   fpcr(SB), $0
        !           167: 
        !           168:        MOVL    new+0(FP), R1
        !           169:        MOVL    FPCR, R0
        !           170:        MOVL    R1, FPCR
        !           171:        RTS
        !           172: 
        !           173: TEXT   rfnote(SB), $0
        !           174: 
        !           175:        MOVL    uregp+0(FP), A7
        !           176:        MOVL    ((8+8)*BY2WD)(A7), A0
        !           177:        MOVL    A0, USP
        !           178:        MOVEM   (A7), $0x7FFF
        !           179:        ADDL    $((8+8+1+1)*BY2WD), A7
        !           180:        RTE
        !           181: 
        !           182: TEXT   illegal(SB), $0
        !           183: 
        !           184:        MOVL    $DBMAGIC, -(A7)
        !           185:        SUBL    $((8+8+1)*BY2WD), A7
        !           186:        MOVEM   $0x7FFF, (A7)
        !           187:        MOVL    $a6base(SB), A6
        !           188:        MOVL    USP, A0
        !           189:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           190:        MOVL    A7, -(A7)
        !           191:        BSR     trap(SB)
        !           192:        ADDL    $4, A7
        !           193:        MOVL    ((8+8)*BY2WD)(A7), A0
        !           194:        MOVL    A0, USP
        !           195:        MOVEM   (A7), $0x7FFF
        !           196:        ADDL    $((8+8+1)*BY2WD), A7
        !           197:        MOVL    $0, (A7)+
        !           198:        RTE
        !           199: 
        !           200: TEXT   systrap(SB), $0
        !           201: 
        !           202:        MOVL    $DBMAGIC, -(A7)
        !           203:        SUBL    $((8+8+1)*BY2WD), A7
        !           204:        MOVL    A6, ((8+6)*BY2WD)(A7)
        !           205:        MOVL    R0, (A7)
        !           206:        MOVL    $a6base(SB), A6
        !           207:        MOVL    USP, A0
        !           208:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           209:        MOVL    A7, -(A7)
        !           210:        BSR     syscall(SB)
        !           211:        MOVL    ((1+8+8)*BY2WD)(A7), A0
        !           212:        MOVL    A0, USP
        !           213:        MOVL    ((1+8+6)*BY2WD)(A7), A6
        !           214:        ADDL    $((1+8+8+1)*BY2WD), A7
        !           215:        MOVL    $0, (A7)+
        !           216:        RTE
        !           217: 
        !           218: TEXT   buserror(SB), $0
        !           219: 
        !           220:        MOVL    $DBMAGIC, -(A7)
        !           221:        SUBL    $((8+8+1)*BY2WD), A7
        !           222:        MOVEM   $0x7FFF, (A7)
        !           223:        MOVL    $a6base(SB), A6
        !           224:        MOVL    USP, A0
        !           225:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           226:        PEA     ((8+8+1+3)*BY2WD)(A7)
        !           227:        PEA     4(A7)
        !           228:        BSR     fault68020(SB)
        !           229:        ADDL    $8, A7
        !           230:        MOVL    ((8+8)*BY2WD)(A7), A0
        !           231:        MOVL    A0, USP
        !           232:        MOVEM   (A7), $0x7FFF
        !           233:        ADDL    $((8+8+1)*BY2WD), A7
        !           234:        MOVL    $0, (A7)+
        !           235:        RTE
        !           236: 
        !           237: TEXT   tacintr(SB), $0                 /* level 1 */
        !           238: 
        !           239:        MOVL    R0, -(A7)
        !           240:        MOVL    TACADDR, R0
        !           241:        MOVL    (A7)+, R0
        !           242:        RTE
        !           243: 
        !           244: TEXT   portintr(SB), $0                /* level 2 */
        !           245: 
        !           246:        MOVL    $DBMAGIC, -(A7)
        !           247:        SUBL    $((8+8+1)*BY2WD), A7
        !           248:        MOVEM   $0x7FFF, (A7)
        !           249:        MOVL    $a6base(SB), A6
        !           250:        MOVL    USP, A0
        !           251:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           252:        MOVL    A7, -(A7)
        !           253:        BSR     devportintr(SB)
        !           254:        BRA     retintr
        !           255: 
        !           256: TEXT   dkintr(SB), $0                  /* level 3 */
        !           257: 
        !           258:        MOVL    $DBMAGIC, -(A7)
        !           259:        SUBL    $((8+8+1)*BY2WD), A7
        !           260:        MOVEM   $0x7FFF, (A7)
        !           261:        MOVL    $a6base(SB), A6
        !           262:        MOVL    USP, A0
        !           263:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           264:        MOVL    A7, -(A7)
        !           265:        BSR     inconintr(SB)
        !           266:        BRA     retintr
        !           267: 
        !           268: TEXT   mouseintr(SB), $0               /* level 4 */
        !           269: 
        !           270:        MOVEM   $0x80C2, -(A7)          /* D0, A0, A1, A6 */
        !           271:        MOVL    $a6base(SB), A6
        !           272:        MOVL    $15, R0                 /* mask off hex switch */
        !           273:        ANDB    MOUSE,R0                /* clears quadrature interrupt */
        !           274:        LEA     mousetab(SB)(R0.W*8), A0
        !           275:        LEA     mouse(SB), A1
        !           276:        MOVL    (A0)+, R0
        !           277:        ADDL    R0, (A1)+               /* dx */
        !           278:        MOVL    (A0), R0
        !           279:        ADDL    R0, (A1)+               /* dy */
        !           280:        ADDL    $1, (A1)                /* track */
        !           281:        MOVEM   (A7)+, $0x4301
        !           282:        RTE
        !           283: 
        !           284: TEXT   uartintr(SB), $0                /* level 5 */
        !           285: 
        !           286:        MOVL    $DBMAGIC, -(A7)
        !           287:        SUBL    $((8+8+1)*BY2WD), A7
        !           288:        MOVEM   $0x7FFF, (A7)
        !           289:        MOVL    $a6base(SB), A6
        !           290:        MOVL    USP, A0
        !           291:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           292:        MOVL    A7, -(A7)
        !           293:        BSR     duartintr(SB)
        !           294:        BRA     retintr
        !           295: 
        !           296: TEXT   syncintr(SB), $0                /* level 6 */
        !           297: 
        !           298:        MOVL    $DBMAGIC, -(A7)
        !           299:        SUBL    $((8+8+1)*BY2WD), A7
        !           300:        MOVEM   $0x7FFF, (A7)
        !           301:        MOVL    $a6base(SB), A6
        !           302:        MOVL    USP, A0
        !           303:        MOVL    A0, ((8+8)*BY2WD)(A7)
        !           304:        MOVL    A7, -(A7)
        !           305:        BSR     clock(SB)
        !           306:        /* fall through */
        !           307: retintr:
        !           308:        ADDL    $4, A7
        !           309:        MOVL    ((8+8)*BY2WD)(A7), A0
        !           310:        MOVL    A0, USP
        !           311:        MOVEM   (A7), $0x7FFF
        !           312:        ADDL    $((8+8+1)*BY2WD), A7
        !           313:        MOVL    $0, (A7)+
        !           314:        RTE
        !           315: 
        !           316: GLOBL  duarttimer+0(SB),$4
        !           317: 
        !           318: TEXT   duartreadtimer+0(SB), $0
        !           319:        MOVW    SR, R1          /* spl7() */
        !           320:        MOVW    $0x2700, SR
        !           321:        MOVL    $0x40100000, A0
        !           322:        CLRL    R0
        !           323:        TSTB    15(A0)          /* stop timer */
        !           324:        MOVW    6(A0), R0       /* read hi,lo */
        !           325:        TSTB    14(A0)          /* restart timer */
        !           326:        NOTW    R0              /* timer counts down from 0xffff */
        !           327:        ADDL    duarttimer(SB), R0
        !           328:        MOVL    R0, duarttimer(SB)
        !           329:        MOVW    R1, SR
        !           330:        RTS
        !           331: 
        !           332: TEXT   getsr+0(SB), $0
        !           333:        MOVL    $0, R0
        !           334:        MOVW    SR, R0
        !           335:        RTS
        !           336: 
        !           337: GLOBL  mousetab(SB), $128
        !           338: DATA   mousetab+  0(SB)/4, -1          /* x down,        */
        !           339: DATA   mousetab+  4(SB)/4,  1          /*         y up   */
        !           340: DATA   mousetab+  8(SB)/4,  0          /* x -            */
        !           341: DATA   mousetab+ 12(SB)/4,  1          /*         y up   */
        !           342: DATA   mousetab+ 16(SB)/4,  1          /* x up           */
        !           343: DATA   mousetab+ 20(SB)/4,  1          /*         y up   */
        !           344: DATA   mousetab+ 24(SB)/4,  0          /* x  -           */
        !           345: DATA   mousetab+ 28(SB)/4,  1          /*         y up   */
        !           346: DATA   mousetab+ 32(SB)/4, -1          /* x down         */
        !           347: DATA   mousetab+ 36(SB)/4,  0          /*         y -    */
        !           348: DATA   mousetab+ 40(SB)/4,  0          /* x -            */
        !           349: DATA   mousetab+ 44(SB)/4,  0          /*         y -    */
        !           350: DATA   mousetab+ 48(SB)/4,  1          /* x up,          */
        !           351: DATA   mousetab+ 52(SB)/4,  0          /*         y -    */
        !           352: DATA   mousetab+ 56(SB)/4,  0          /* x -            */
        !           353: DATA   mousetab+ 60(SB)/4,  0          /*         y -    */
        !           354: DATA   mousetab+ 64(SB)/4, -1          /* x down         */
        !           355: DATA   mousetab+ 68(SB)/4, -1          /*         y down */
        !           356: DATA   mousetab+ 72(SB)/4,  0          /* x -            */
        !           357: DATA   mousetab+ 76(SB)/4, -1          /*         y down */
        !           358: DATA   mousetab+ 80(SB)/4,  1          /* x up           */
        !           359: DATA   mousetab+ 84(SB)/4, -1          /*         y down */
        !           360: DATA   mousetab+ 88(SB)/4,  0          /* x -            */
        !           361: DATA   mousetab+ 92(SB)/4, -1          /*         y down */
        !           362: DATA   mousetab+ 96(SB)/4, -1          /* x down         */
        !           363: DATA   mousetab+100(SB)/4,  0          /*         y -    */
        !           364: DATA   mousetab+104(SB)/4,  0          /* x -            */
        !           365: DATA   mousetab+108(SB)/4,  0          /*         y -    */
        !           366: DATA   mousetab+112(SB)/4,  1          /* x up           */
        !           367: DATA   mousetab+116(SB)/4,  0          /*         y -    */
        !           368: DATA   mousetab+120(SB)/4,  0          /* x -            */
        !           369: DATA   mousetab+124(SB)/4,  0          /*         y -    */
        !           370: 
        !           371: GLOBL  mach0+0(SB), $MACHSIZE
        !           372: GLOBL  u(SB), $4
        !           373: GLOBL  m(SB), $4

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.