sys/sparc64/sparc64/interrupt.S

   1 /*-
   2  * Copyright (c) 2002 Jake Burkholder.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <machine/asm.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <machine/asi.h>
  31 #include <machine/asmacros.h>
  32 #include <machine/intr_machdep.h>
  33 #include <machine/ktr.h>
  34 #include <machine/pstate.h>
  35
  36 #include "assym.s"
  37
  38 /*
  39  * Handle a vectored interrupt.
  40  *
  41  * This is either a data bearing mondo vector interrupt, or a cross trap
  42  * request from another cpu.  In either case the hardware supplies an
  43  * interrupt packet, in the form of 3 data words which are read from internal
  44  * registers.  A data bearing mondo vector packet consists of an interrupt
  45  * number in the first data word, and zero in 2nd and 3rd.  We use the
  46  * interrupt number to find the function, argument and priority from the
  47  * intr_vector table, allocate and fill in an intr_request from the per-cpu
  48  * free list, link it onto the per-cpu active list and finally post a softint
  49  * at the desired priority.  Cross trap requests come in 2 forms, direct
  50  * and queued.  Direct requests are distinguished by the first data word
  51  * being zero.  The 2nd data word carries a function to call and the 3rd
  52  * an argument to pass.  The function is jumped to directly.  It executes
  53  * in nucleus context on interrupt globals and with all interrupts disabled,
  54  * therefore it must be fast, and the things that it can do are limited.
  55  * Queued cross trap requests are handled much like mondo vectors, except
  56  * that the function, argument and priority are contained in the interrupt
  57  * packet itself.  They are distinguished by the upper 4 bits of the data
  58  * word being non-zero, which specifies the priority of the softint to
  59  * deliver.
  60  *
  61  * Register usage:
  62  *      %g1 - pointer to intr_request
  63  *      %g2 - pointer to intr_vector, temp once required data is loaded
  64  *      %g3 - interrupt number for mondo vectors, unused otherwise
  65  *      %g4 - function, from the interrupt packet for cross traps, or
  66  *            loaded from the interrupt registers for mondo vecors
  67  *      %g5 - argument, as above for %g4
  68  *      %g6 - softint priority
  69  */
  70 ENTRY(intr_vector)
  71         /*
  72          * Load the interrupt packet from the hardware.
  73          */
  74         wr      %g0, ASI_SDB_INTR_R, %asi
  75         ldxa    [%g0 + AA_SDB_INTR_D0] %asi, %g3
  76         ldxa    [%g0 + AA_SDB_INTR_D1] %asi, %g4
  77         ldxa    [%g0 + AA_SDB_INTR_D2] %asi, %g5
  78         stxa    %g0, [%g0] ASI_INTR_RECEIVE
  79         membar  #Sync
  80
  81         /*
  82          * If the first data word is zero this is a direct cross trap request.
  83          * The 2nd word points to code to execute and the 3rd is an argument
  84          * to pass.  Jump to it.
  85          */
  86         brnz,pt %g3, 1f
  87         /*
  88          * NB: Zeus CPUs set some undocumented bits in the first data word.
  89          */
  90          and    %g3, IV_MAX - 1, %g3
  91         jmpl    %g4, %g0
  92          nop
  93         /* NOTREACHED */
  94
  95         /*
  96          * If the high 4 bits of the 1st data word are non-zero, this is a
  97          * queued cross trap request to be delivered as a softint.  The high
  98          * 4 bits of the 1st data word specify a priority, and the 2nd and
  99          * 3rd a function and argument.
 100          */
 101 1:      srlx    %g3, 60, %g6
 102         brnz,a,pn %g6, 2f
 103          clr    %g3
 104
 105         /*
 106          * Find the function, argument and desired priority from the
 107          * intr_vector table.
 108          */
 109         SET(intr_vectors, %g4, %g2)
 110         sllx    %g3, IV_SHIFT, %g4
 111         add     %g2, %g4, %g2
 112
 113         ldx     [%g2 + IV_FUNC], %g4
 114         ldx     [%g2 + IV_ARG], %g5
 115         lduw    [%g2 + IV_PRI], %g6
 116
 117         /*
 118          * Get an intr_request from the free list.  There should always be one
 119          * unless we are getting an interrupt storm from stray interrupts, in
 120          * which case the we will deference a NULL pointer and panic.
 121          */
 122 2:      ldx     [PCPU(IRFREE)], %g1
 123         ldx     [%g1 + IR_NEXT], %g2
 124         stx     %g2, [PCPU(IRFREE)]
 125
 126         /*
 127          * Store the vector number, function, argument and priority.
 128          */
 129         stw     %g3, [%g1 + IR_VEC]
 130         stx     %g4, [%g1 + IR_FUNC]
 131         stx     %g5, [%g1 + IR_ARG]
 132         stw     %g6, [%g1 + IR_PRI]
 133
 134         /*
 135          * Link it onto the end of the active list.
 136          */
 137         stx     %g0, [%g1 + IR_NEXT]
 138         ldx     [PCPU(IRTAIL)], %g4
 139         stx     %g1, [%g4]
 140         add     %g1, IR_NEXT, %g1
 141         stx     %g1, [PCPU(IRTAIL)]
 142
 143         /*
 144          * Trigger a softint at the level indicated by the priority.
 145          */
 146         mov     1, %g1
 147         sllx    %g1, %g6, %g1
 148         wr      %g1, 0, %set_softint
 149
 150         /*
 151          * Done, retry the instruction.
 152          */
 153         retry
 154 END(intr_vector)
 155
 156 ENTRY(intr_fast)
 157         save    %sp, -CCFSZ, %sp
 158
 159         /*
 160          * Disable interrupts while we fiddle with the interrupt request lists
 161          * as interrupts at levels higher than what got us here aren't blocked.
 162          */
 163 1:      wrpr    %g0, PSTATE_NORMAL, %pstate
 164
 165         ldx     [PCPU(IRHEAD)], %l0
 166         brnz,a,pt %l0, 2f
 167          nop
 168
 169         wrpr    %g0, PSTATE_KERNEL, %pstate
 170
 171         ret
 172          restore
 173
 174 2:      ldx     [%l0 + IR_NEXT], %l1
 175         brnz,pt %l1, 3f
 176          stx    %l1, [PCPU(IRHEAD)]
 177         PCPU_ADDR(IRHEAD, %l1)
 178         stx     %l1, [PCPU(IRTAIL)]
 179
 180 3:      ldx     [%l0 + IR_FUNC], %o0
 181         ldx     [%l0 + IR_ARG], %o1
 182         lduw    [%l0 + IR_VEC], %l2
 183
 184         ldx     [PCPU(IRFREE)], %l1
 185         stx     %l1, [%l0 + IR_NEXT]
 186         stx     %l0, [PCPU(IRFREE)]
 187
 188         wrpr    %g0, PSTATE_KERNEL, %pstate
 189
 190         KASSERT(%o0, "intr_fast: ir_func null")
 191         call    %o0
 192          mov    %o1, %o0
 193
 194         /* intrcnt[intr_countp[%l2]]++ */
 195         SET(intrcnt, %l7, %l3)          /* %l3 = intrcnt */
 196         prefetcha [%l3] ASI_N, 1
 197         SET(intr_countp, %l7, %l4)      /* %l4 = intr_countp */
 198         sllx    %l2, 1, %l2             /* %l2 = vec << 1 */
 199         lduh    [%l4 + %l2], %l4        /* %l4 = intr_countp[%l2] */
 200         sllx    %l4, 3, %l4             /* %l4 = intr_countp[%l2] << 3 */
 201         add     %l4, %l3, %l4           /* %l4 = intrcnt[intr_countp[%l2]] */
 202         ldx     [%l4], %l2
 203         inc     %l2
 204         stx     %l2, [%l4]
 205
 206         ba,a    %xcc, 1b
 207          nop
 208 END(intr_fast)