drivers/irqchip/irq-gic-common.c

   1 /*
   2  * Copyright (C) 2002 ARM Limited, All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include <linux/interrupt.h>
  18 #include <linux/io.h>
  19 #include <linux/irq.h>
  20 #include <linux/irqchip/arm-gic.h>
  21
  22 #include "irq-gic-common.h"
  23
  24 void gic_enable_quirks(u32 iidr, const struct gic_quirk *quirks,
  25                 void *data)
  26 {
  27         for (; quirks->desc; quirks++) {
  28                 if (quirks->iidr != (quirks->mask & iidr))
  29                         continue;
  30                 quirks->init(data);
  31                 pr_info("GIC: enabling workaround for %s\n", quirks->desc);
  32         }
  33 }
  34
  35 int gic_configure_irq(unsigned int irq, unsigned int type,
  36                        void __iomem *base, void (*sync_access)(void))
  37 {
  38         u32 confmask = 0x2 << ((irq % 16) * 2);
  39         u32 confoff = (irq / 16) * 4;
  40         u32 val, oldval;
  41         int ret = 0;
  42
  43         /*
  44          * Read current configuration register, and insert the config
  45          * for "irq", depending on "type".
  46          */
  47         val = oldval = readl_relaxed(base + GIC_DIST_CONFIG + confoff);
  48         if (type & IRQ_TYPE_LEVEL_MASK)
  49                 val &= ~confmask;
  50         else if (type & IRQ_TYPE_EDGE_BOTH)
  51                 val |= confmask;
  52
  53         /* If the current configuration is the same, then we are done */
  54         if (val == oldval)
  55                 return 0;
  56
  57         /*
  58          * Write back the new configuration, and possibly re-enable
  59          * the interrupt. If we fail to write a new configuration for
  60          * an SPI then WARN and return an error. If we fail to write the
  61          * configuration for a PPI this is most likely because the GIC
  62          * does not allow us to set the configuration or we are in a
  63          * non-secure mode, and hence it may not be catastrophic.
  64          */
  65         writel_relaxed(val, base + GIC_DIST_CONFIG + confoff);
  66         if (readl_relaxed(base + GIC_DIST_CONFIG + confoff) != val) {
  67                 if (WARN_ON(irq >= 32))
  68                         ret = -EINVAL;
  69                 else
  70                         pr_warn("GIC: PPI%d is secure or misconfigured\n",
  71                                 irq - 16);
  72         }
  73
  74         if (sync_access)
  75                 sync_access();
  76
  77         return ret;
  78 }
  79
  80 void __init gic_dist_config(void __iomem *base, int gic_irqs,
  81                             void (*sync_access)(void))
  82 {
  83         unsigned int i;
  84
  85         /*
  86          * Set all global interrupts to be level triggered, active low.
  87          */
  88         for (i = 32; i < gic_irqs; i += 16)
  89                 writel_relaxed(GICD_INT_ACTLOW_LVLTRIG,
  90                                         base + GIC_DIST_CONFIG + i / 4);
  91
  92         /*
  93          * Set priority on all global interrupts.
  94          */
  95         for (i = 32; i < gic_irqs; i += 4)
  96                 writel_relaxed(GICD_INT_DEF_PRI_X4, base + GIC_DIST_PRI + i);
  97
  98         /*
  99          * Deactivate and disable all SPIs. Leave the PPI and SGIs
 100          * alone as they are in the redistributor registers on GICv3.
 101          */
 102         for (i = 32; i < gic_irqs; i += 32) {
 103                 writel_relaxed(GICD_INT_EN_CLR_X32,
 104                                base + GIC_DIST_ACTIVE_CLEAR + i / 8);
 105                 writel_relaxed(GICD_INT_EN_CLR_X32,
 106                                base + GIC_DIST_ENABLE_CLEAR + i / 8);
 107         }
 108
 109         if (sync_access)
 110                 sync_access();
 111 }
 112
 113 void gic_cpu_config(void __iomem *base, void (*sync_access)(void))
 114 {
 115         int i;
 116
 117         /*
 118          * Deal with the banked PPI and SGI interrupts - disable all
 119          * PPI interrupts, ensure all SGI interrupts are enabled.
 120          * Make sure everything is deactivated.
 121          */
 122         writel_relaxed(GICD_INT_EN_CLR_X32, base + GIC_DIST_ACTIVE_CLEAR);
 123         writel_relaxed(GICD_INT_EN_CLR_PPI, base + GIC_DIST_ENABLE_CLEAR);
 124         writel_relaxed(GICD_INT_EN_SET_SGI, base + GIC_DIST_ENABLE_SET);
 125
 126         /*
 127          * Set priority on PPI and SGI interrupts
 128          */
 129         for (i = 0; i < 32; i += 4)
 130                 writel_relaxed(GICD_INT_DEF_PRI_X4,
 131                                         base + GIC_DIST_PRI + i * 4 / 4);
 132
 133         if (sync_access)
 134                 sync_access();
 135 }