arch/powerpc/cpu/mpc8xx/interrupts.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2002
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #include <common.h>
   8 #include <irq_func.h>
   9 #include <mpc8xx.h>
  10 #include <mpc8xx_irq.h>
  11 #include <time.h>
  12 #include <asm/cpm_8xx.h>
  13 #include <asm/processor.h>
  14 #include <asm/io.h>
  15
  16 /************************************************************************/
  17
  18 /*
  19  * CPM interrupt vector functions.
  20  */
  21 struct interrupt_action {
  22         interrupt_handler_t *handler;
  23         void *arg;
  24 };
  25
  26 static struct interrupt_action cpm_vecs[CPMVEC_NR];
  27 static struct interrupt_action irq_vecs[NR_IRQS];
  28
  29 static void cpm_interrupt_init(void);
  30 static void cpm_interrupt(void *regs);
  31
  32 /************************************************************************/
  33
  34 void interrupt_init_cpu(unsigned *decrementer_count)
  35 {
  36         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
  37
  38         *decrementer_count = get_tbclk() / CONFIG_SYS_HZ;
  39
  40         /* disable all interrupts */
  41         out_be32(&immr->im_siu_conf.sc_simask, 0);
  42
  43         /* Configure CPM interrupts */
  44         cpm_interrupt_init();
  45 }
  46
  47 /************************************************************************/
  48
  49 /*
  50  * Handle external interrupts
  51  */
  52 void external_interrupt(struct pt_regs *regs)
  53 {
  54         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
  55         int irq;
  56         ulong simask;
  57         ulong vec, v_bit;
  58
  59         /*
  60          * read the SIVEC register and shift the bits down
  61          * to get the irq number
  62          */
  63         vec = in_be32(&immr->im_siu_conf.sc_sivec);
  64         irq = vec >> 26;
  65         v_bit = 0x80000000UL >> irq;
  66
  67         /*
  68          * Read Interrupt Mask Register and Mask Interrupts
  69          */
  70         simask = in_be32(&immr->im_siu_conf.sc_simask);
  71         clrbits_be32(&immr->im_siu_conf.sc_simask, 0xFFFF0000 >> irq);
  72
  73         if (!(irq & 0x1)) {             /* External Interrupt ?     */
  74                 ulong siel;
  75
  76                 /*
  77                  * Read Interrupt Edge/Level Register
  78                  */
  79                 siel = in_be32(&immr->im_siu_conf.sc_siel);
  80
  81                 if (siel & v_bit) {     /* edge triggered interrupt ?   */
  82                         /*
  83                          * Rewrite SIPEND Register to clear interrupt
  84                          */
  85                         out_be32(&immr->im_siu_conf.sc_sipend, v_bit);
  86                 }
  87         }
  88
  89         if (irq_vecs[irq].handler != NULL) {
  90                 irq_vecs[irq].handler(irq_vecs[irq].arg);
  91         } else {
  92                 printf("\nBogus External Interrupt IRQ %d Vector %ld\n",
  93                        irq, vec);
  94                 /* turn off the bogus interrupt to avoid it from now */
  95                 simask &= ~v_bit;
  96         }
  97         /*
  98          * Re-Enable old Interrupt Mask
  99          */
 100         out_be32(&immr->im_siu_conf.sc_simask, simask);
 101 }
 102
 103 /************************************************************************/
 104
 105 /*
 106  * CPM interrupt handler
 107  */
 108 static void cpm_interrupt(void *regs)
 109 {
 110         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
 111         uint vec;
 112
 113         /*
 114          * Get the vector by setting the ACK bit
 115          * and then reading the register.
 116          */
 117         out_be16(&immr->im_cpic.cpic_civr, 1);
 118         vec = in_be16(&immr->im_cpic.cpic_civr);
 119         vec >>= 11;
 120
 121         if (cpm_vecs[vec].handler != NULL) {
 122                 (*cpm_vecs[vec].handler) (cpm_vecs[vec].arg);
 123         } else {
 124                 clrbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
 125                 printf("Masking bogus CPM interrupt vector 0x%x\n", vec);
 126         }
 127         /*
 128          * After servicing the interrupt,
 129          * we have to remove the status indicator.
 130          */
 131         setbits_be32(&immr->im_cpic.cpic_cisr, 1 << vec);
 132 }
 133
 134 /*
 135  * The CPM can generate the error interrupt when there is a race
 136  * condition between generating and masking interrupts. All we have
 137  * to do is ACK it and return. This is a no-op function so we don't
 138  * need any special tests in the interrupt handler.
 139  */
 140 static void cpm_error_interrupt(void *dummy)
 141 {
 142 }
 143
 144 /************************************************************************/
 145 /*
 146  * Install and free an interrupt handler
 147  */
 148 void irq_install_handler(int vec, interrupt_handler_t *handler, void *arg)
 149 {
 150         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
 151
 152         if ((vec & CPMVEC_OFFSET) != 0) {
 153                 /* CPM interrupt */
 154                 vec &= 0xffff;
 155                 if (cpm_vecs[vec].handler != NULL)
 156                         printf("CPM interrupt 0x%x replacing 0x%x\n",
 157                                (uint)handler, (uint)cpm_vecs[vec].handler);
 158                 cpm_vecs[vec].handler = handler;
 159                 cpm_vecs[vec].arg = arg;
 160                 setbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
 161         } else {
 162                 /* SIU interrupt */
 163                 if (irq_vecs[vec].handler != NULL)
 164                         printf("SIU interrupt %d 0x%x replacing 0x%x\n",
 165                                vec, (uint)handler, (uint)cpm_vecs[vec].handler);
 166                 irq_vecs[vec].handler = handler;
 167                 irq_vecs[vec].arg = arg;
 168                 setbits_be32(&immr->im_siu_conf.sc_simask, 1 << (31 - vec));
 169         }
 170 }
 171
 172 void irq_free_handler(int vec)
 173 {
 174         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
 175
 176         if ((vec & CPMVEC_OFFSET) != 0) {
 177                 /* CPM interrupt */
 178                 vec &= 0xffff;
 179                 clrbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
 180                 cpm_vecs[vec].handler = NULL;
 181                 cpm_vecs[vec].arg = NULL;
 182         } else {
 183                 /* SIU interrupt */
 184                 clrbits_be32(&immr->im_siu_conf.sc_simask, 1 << (31 - vec));
 185                 irq_vecs[vec].handler = NULL;
 186                 irq_vecs[vec].arg = NULL;
 187         }
 188 }
 189
 190 /************************************************************************/
 191
 192 static void cpm_interrupt_init(void)
 193 {
 194         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
 195         uint cicr;
 196
 197         /*
 198          * Initialize the CPM interrupt controller.
 199          */
 200
 201         cicr = CICR_SCD_SCC4 | CICR_SCC_SCC3 | CICR_SCB_SCC2 | CICR_SCA_SCC1 |
 202                ((CPM_INTERRUPT / 2) << 13) | CICR_HP_MASK;
 203
 204         out_be32(&immr->im_cpic.cpic_cicr, cicr);
 205         out_be32(&immr->im_cpic.cpic_cimr, 0);
 206
 207         /*
 208          * Install the error handler.
 209          */
 210         irq_install_handler(CPMVEC_ERROR, cpm_error_interrupt, NULL);
 211
 212         setbits_be32(&immr->im_cpic.cpic_cicr, CICR_IEN);
 213
 214         /*
 215          * Install the cpm interrupt handler
 216          */
 217         irq_install_handler(CPM_INTERRUPT, cpm_interrupt, NULL);
 218 }
 219
 220 /************************************************************************/
 221
 222 /*
 223  * timer_interrupt - gets called when the decrementer overflows,
 224  * with interrupts disabled.
 225  * Trivial implementation - no need to be really accurate.
 226  */
 227 void timer_interrupt_cpu(struct pt_regs *regs)
 228 {
 229         immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
 230
 231         /* Reset Timer Expired and Timers Interrupt Status */
 232         out_be32(&immr->im_clkrstk.cark_plprcrk, KAPWR_KEY);
 233         __asm__ ("nop");
 234         /*
 235           Clear TEXPS (and TMIST on older chips). SPLSS (on older
 236           chips) is cleared too.
 237
 238           Bitwise OR is a read-modify-write operation so ALL bits
 239           which are cleared by writing `1' would be cleared by
 240           operations like
 241
 242           immr->im_clkrst.car_plprcr |= PLPRCR_TEXPS;
 243
 244           The same can be achieved by simple writing of the PLPRCR
 245           to itself. If a bit value should be preserved, read the
 246           register, ZERO the bit and write, not OR, the result back.
 247         */
 248         setbits_be32(&immr->im_clkrst.car_plprcr, 0);
 249 }
 250
 251 /************************************************************************/