kernel/drivers/irqchip/irq-gic.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  * Interrupt architecture for the GIC:
   9  *
  10  * o There is one Interrupt Distributor, which receives interrupts
  11  *   from system devices and sends them to the Interrupt Controllers.
  12  *
  13  * o There is one CPU Interface per CPU, which sends interrupts sent
  14  *   by the Distributor, and interrupts generated locally, to the
  15  *   associated CPU. The base address of the CPU interface is usually
  16  *   aliased so that the same address points to different chips depending
  17  *   on the CPU it is accessed from.
  18  *
  19  * Note that IRQs 0-31 are special - they are local to each CPU.
  20  * As such, the enable set/clear, pending set/clear and active bit
  21  * registers are banked per-cpu for these sources.
  22  */
  23 #include <linux/init.h>
  24 #include <linux/kernel.h>
  25 #include <linux/err.h>
  26 #include <linux/module.h>
  27 #include <linux/list.h>
  28 #include <linux/smp.h>
  29 #include <linux/cpu.h>
  30 #include <linux/cpu_pm.h>
  31 #include <linux/cpumask.h>
  32 #include <linux/io.h>
  33 #include <linux/of.h>
  34 #include <linux/of_address.h>
  35 #include <linux/of_irq.h>
  36 #include <linux/acpi.h>
  37 #include <linux/irqdomain.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/percpu.h>
  40 #include <linux/slab.h>
  41 #include <linux/irqchip.h>
  42 #include <linux/irqchip/chained_irq.h>
  43 #include <linux/irqchip/arm-gic.h>
  44
  45 #include <asm/cputype.h>
  46 #include <asm/irq.h>
  47 #include <asm/exception.h>
  48 #include <asm/smp_plat.h>
  49 #include <asm/virt.h>
  50
  51 #include "irq-gic-common.h"
  52
  53 #ifdef CONFIG_ARM64
  54 #include <asm/cpufeature.h>
  55
  56 static void gic_check_cpu_features(void)
  57 {
  58         WARN_TAINT_ONCE(cpus_have_cap(ARM64_HAS_SYSREG_GIC_CPUIF),
  59                         TAINT_CPU_OUT_OF_SPEC,
  60                         "GICv3 system registers enabled, broken firmware!\n");
  61 }
  62 #else
  63 #define gic_check_cpu_features()        do { } while(0)
  64 #endif
  65
  66 union gic_base {
  67         void __iomem *common_base;
  68         void __percpu * __iomem *percpu_base;
  69 };
  70
  71 struct gic_chip_data {
  72         union gic_base dist_base;
  73         union gic_base cpu_base;
  74 #ifdef CONFIG_CPU_PM
  75         u32 saved_spi_enable[DIV_ROUND_UP(1020, 32)];
  76         u32 saved_spi_active[DIV_ROUND_UP(1020, 32)];
  77         u32 saved_spi_conf[DIV_ROUND_UP(1020, 16)];
  78         u32 saved_spi_target[DIV_ROUND_UP(1020, 4)];
  79         u32 __percpu *saved_ppi_enable;
  80         u32 __percpu *saved_ppi_active;
  81         u32 __percpu *saved_ppi_conf;
  82 #endif
  83         struct irq_domain *domain;
  84         unsigned int gic_irqs;
  85 #ifdef CONFIG_GIC_NON_BANKED
  86         void __iomem *(*get_base)(union gic_base *);
  87 #endif
  88 };
  89
  90 static DEFINE_RAW_SPINLOCK(irq_controller_lock);
  91
  92 /*
  93  * The GIC mapping of CPU interfaces does not necessarily match
  94  * the logical CPU numbering.  Let's use a mapping as returned
  95  * by the GIC itself.
  96  */
  97 #define NR_GIC_CPU_IF 8
  98 static u8 gic_cpu_map[NR_GIC_CPU_IF] __read_mostly;
  99
 100 static struct static_key supports_deactivate = STATIC_KEY_INIT_TRUE;
 101
 102 #ifndef MAX_GIC_NR
 103 #define MAX_GIC_NR      1
 104 #endif
 105
 106 static struct gic_chip_data gic_data[MAX_GIC_NR] __read_mostly;
 107
 108 #ifdef CONFIG_GIC_NON_BANKED
 109 static void __iomem *gic_get_percpu_base(union gic_base *base)
 110 {
 111         return raw_cpu_read(*base->percpu_base);
 112 }
 113
 114 static void __iomem *gic_get_common_base(union gic_base *base)
 115 {
 116         return base->common_base;
 117 }
 118
 119 static inline void __iomem *gic_data_dist_base(struct gic_chip_data *data)
 120 {
 121         return data->get_base(&data->dist_base);
 122 }
 123
 124 static inline void __iomem *gic_data_cpu_base(struct gic_chip_data *data)
 125 {
 126         return data->get_base(&data->cpu_base);
 127 }
 128
 129 static inline void gic_set_base_accessor(struct gic_chip_data *data,
 130                                          void __iomem *(*f)(union gic_base *))
 131 {
 132         data->get_base = f;
 133 }
 134 #else
 135 #define gic_data_dist_base(d)   ((d)->dist_base.common_base)
 136 #define gic_data_cpu_base(d)    ((d)->cpu_base.common_base)
 137 #define gic_set_base_accessor(d, f)
 138 #endif
 139
 140 static inline void __iomem *gic_dist_base(struct irq_data *d)
 141 {
 142         struct gic_chip_data *gic_data = irq_data_get_irq_chip_data(d);
 143         return gic_data_dist_base(gic_data);
 144 }
 145
 146 static inline void __iomem *gic_cpu_base(struct irq_data *d)
 147 {
 148         struct gic_chip_data *gic_data = irq_data_get_irq_chip_data(d);
 149         return gic_data_cpu_base(gic_data);
 150 }
 151
 152 static inline unsigned int gic_irq(struct irq_data *d)
 153 {
 154         return d->hwirq;
 155 }
 156
 157 static inline bool cascading_gic_irq(struct irq_data *d)
 158 {
 159         void *data = irq_data_get_irq_handler_data(d);
 160
 161         /*
 162          * If handler_data is set, this is a cascading interrupt, and
 163          * it cannot possibly be forwarded.
 164          */
 165         return data != NULL;
 166 }
 167
 168 /*
 169  * Routines to acknowledge, disable and enable interrupts
 170  */
 171 static void gic_poke_irq(struct irq_data *d, u32 offset)
 172 {
 173         u32 mask = 1 << (gic_irq(d) % 32);
 174         writel_relaxed(mask, gic_dist_base(d) + offset + (gic_irq(d) / 32) * 4);
 175 }
 176
 177 static int gic_peek_irq(struct irq_data *d, u32 offset)
 178 {
 179         u32 mask = 1 << (gic_irq(d) % 32);
 180         return !!(readl_relaxed(gic_dist_base(d) + offset + (gic_irq(d) / 32) * 4) & mask);
 181 }
 182
 183 static void gic_mask_irq(struct irq_data *d)
 184 {
 185         gic_poke_irq(d, GIC_DIST_ENABLE_CLEAR);
 186 }
 187
 188 static void gic_eoimode1_mask_irq(struct irq_data *d)
 189 {
 190         gic_mask_irq(d);
 191         /*
 192          * When masking a forwarded interrupt, make sure it is
 193          * deactivated as well.
 194          *
 195          * This ensures that an interrupt that is getting
 196          * disabled/masked will not get "stuck", because there is
 197          * noone to deactivate it (guest is being terminated).
 198          */
 199         if (irqd_is_forwarded_to_vcpu(d))
 200                 gic_poke_irq(d, GIC_DIST_ACTIVE_CLEAR);
 201 }
 202
 203 static void gic_unmask_irq(struct irq_data *d)
 204 {
 205         gic_poke_irq(d, GIC_DIST_ENABLE_SET);
 206 }
 207
 208 static void gic_eoi_irq(struct irq_data *d)
 209 {
 210         writel_relaxed(gic_irq(d), gic_cpu_base(d) + GIC_CPU_EOI);
 211 }
 212
 213 static void gic_eoimode1_eoi_irq(struct irq_data *d)
 214 {
 215         /* Do not deactivate an IRQ forwarded to a vcpu. */
 216         if (irqd_is_forwarded_to_vcpu(d))
 217                 return;
 218
 219         writel_relaxed(gic_irq(d), gic_cpu_base(d) + GIC_CPU_DEACTIVATE);
 220 }
 221
 222 static int gic_irq_set_irqchip_state(struct irq_data *d,
 223                                      enum irqchip_irq_state which, bool val)
 224 {
 225         u32 reg;
 226
 227         switch (which) {
 228         case IRQCHIP_STATE_PENDING:
 229                 reg = val ? GIC_DIST_PENDING_SET : GIC_DIST_PENDING_CLEAR;
 230                 break;
 231
 232         case IRQCHIP_STATE_ACTIVE:
 233                 reg = val ? GIC_DIST_ACTIVE_SET : GIC_DIST_ACTIVE_CLEAR;
 234                 break;
 235
 236         case IRQCHIP_STATE_MASKED:
 237                 reg = val ? GIC_DIST_ENABLE_CLEAR : GIC_DIST_ENABLE_SET;
 238                 break;
 239
 240         default:
 241                 return -EINVAL;
 242         }
 243
 244         gic_poke_irq(d, reg);
 245         return 0;
 246 }
 247
 248 static int gic_irq_get_irqchip_state(struct irq_data *d,
 249                                       enum irqchip_irq_state which, bool *val)
 250 {
 251         switch (which) {
 252         case IRQCHIP_STATE_PENDING:
 253                 *val = gic_peek_irq(d, GIC_DIST_PENDING_SET);
 254                 break;
 255
 256         case IRQCHIP_STATE_ACTIVE:
 257                 *val = gic_peek_irq(d, GIC_DIST_ACTIVE_SET);
 258                 break;
 259
 260         case IRQCHIP_STATE_MASKED:
 261                 *val = !gic_peek_irq(d, GIC_DIST_ENABLE_SET);
 262                 break;
 263
 264         default:
 265                 return -EINVAL;
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int gic_set_type(struct irq_data *d, unsigned int type)
 272 {
 273         void __iomem *base = gic_dist_base(d);
 274         unsigned int gicirq = gic_irq(d);
 275
 276         /* Interrupt configuration for SGIs can't be changed */
 277         if (gicirq < 16)
 278                 return -EINVAL;
 279
 280         /* SPIs have restrictions on the supported types */
 281         if (gicirq >= 32 && type != IRQ_TYPE_LEVEL_HIGH &&
 282                             type != IRQ_TYPE_EDGE_RISING)
 283                 return -EINVAL;
 284
 285         return gic_configure_irq(gicirq, type, base, NULL);
 286 }
 287
 288 static int gic_irq_set_vcpu_affinity(struct irq_data *d, void *vcpu)
 289 {
 290         /* Only interrupts on the primary GIC can be forwarded to a vcpu. */
 291         if (cascading_gic_irq(d))
 292                 return -EINVAL;
 293
 294         if (vcpu)
 295                 irqd_set_forwarded_to_vcpu(d);
 296         else
 297                 irqd_clr_forwarded_to_vcpu(d);
 298         return 0;
 299 }
 300
 301 #ifdef CONFIG_SMP
 302 static int gic_set_affinity(struct irq_data *d, const struct cpumask *mask_val,
 303                             bool force)
 304 {
 305         void __iomem *reg = gic_dist_base(d) + GIC_DIST_TARGET + (gic_irq(d) & ~3);
 306         unsigned int cpu, shift = (gic_irq(d) % 4) * 8;
 307         u32 val, mask, bit;
 308         unsigned long flags;
 309
 310         if (!force)
 311                 cpu = cpumask_any_and(mask_val, cpu_online_mask);
 312         else
 313                 cpu = cpumask_first(mask_val);
 314
 315         if (cpu >= NR_GIC_CPU_IF || cpu >= nr_cpu_ids)
 316                 return -EINVAL;
 317
 318         raw_spin_lock_irqsave(&irq_controller_lock, flags);
 319         mask = 0xff << shift;
 320         bit = gic_cpu_map[cpu] << shift;
 321         val = readl_relaxed(reg) & ~mask;
 322         writel_relaxed(val | bit, reg);
 323         raw_spin_unlock_irqrestore(&irq_controller_lock, flags);
 324
 325         return IRQ_SET_MASK_OK;
 326 }
 327 #endif
 328
 329 static void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
 330 {
 331         u32 irqstat, irqnr;
 332         struct gic_chip_data *gic = &gic_data[0];
 333         void __iomem *cpu_base = gic_data_cpu_base(gic);
 334
 335         do {
 336                 irqstat = readl_relaxed(cpu_base + GIC_CPU_INTACK);
 337                 irqnr = irqstat & GICC_IAR_INT_ID_MASK;
 338
 339                 if (likely(irqnr > 15 && irqnr < 1021)) {
 340                         if (static_key_true(&supports_deactivate))
 341                                 writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
 342                         handle_domain_irq(gic->domain, irqnr, regs);
 343                         continue;
 344                 }
 345                 if (irqnr < 16) {
 346                         writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
 347                         if (static_key_true(&supports_deactivate))
 348                                 writel_relaxed(irqstat, cpu_base + GIC_CPU_DEACTIVATE);
 349 #ifdef CONFIG_SMP
 350                         /*
 351                          * Ensure any shared data written by the CPU sending
 352                          * the IPI is read after we've read the ACK register
 353                          * on the GIC.
 354                          *
 355                          * Pairs with the write barrier in gic_raise_softirq
 356                          */
 357                         smp_rmb();
 358                         handle_IPI(irqnr, regs);
 359 #endif
 360                         continue;
 361                 }
 362                 break;
 363         } while (1);
 364 }
 365
 366 static void gic_handle_cascade_irq(struct irq_desc *desc)
 367 {
 368         struct gic_chip_data *chip_data = irq_desc_get_handler_data(desc);
 369         struct irq_chip *chip = irq_desc_get_chip(desc);
 370         unsigned int cascade_irq, gic_irq;
 371         unsigned long status;
 372
 373         chained_irq_enter(chip, desc);
 374
 375         raw_spin_lock(&irq_controller_lock);
 376         status = readl_relaxed(gic_data_cpu_base(chip_data) + GIC_CPU_INTACK);
 377         raw_spin_unlock(&irq_controller_lock);
 378
 379         gic_irq = (status & GICC_IAR_INT_ID_MASK);
 380         if (gic_irq == GICC_INT_SPURIOUS)
 381                 goto out;
 382
 383         cascade_irq = irq_find_mapping(chip_data->domain, gic_irq);
 384         if (unlikely(gic_irq < 32 || gic_irq > 1020))
 385                 handle_bad_irq(desc);
 386         else
 387                 generic_handle_irq(cascade_irq);
 388
 389  out:
 390         chained_irq_exit(chip, desc);
 391 }
 392
 393 static struct irq_chip gic_chip = {
 394         .name                   = "GIC",
 395         .irq_mask               = gic_mask_irq,
 396         .irq_unmask             = gic_unmask_irq,
 397         .irq_eoi                = gic_eoi_irq,
 398         .irq_set_type           = gic_set_type,
 399 #ifdef CONFIG_SMP
 400         .irq_set_affinity       = gic_set_affinity,
 401 #endif
 402         .irq_get_irqchip_state  = gic_irq_get_irqchip_state,
 403         .irq_set_irqchip_state  = gic_irq_set_irqchip_state,
 404         .flags                  = IRQCHIP_SET_TYPE_MASKED |
 405                                   IRQCHIP_SKIP_SET_WAKE |
 406                                   IRQCHIP_MASK_ON_SUSPEND,
 407 };
 408
 409 static struct irq_chip gic_eoimode1_chip = {
 410         .name                   = "GICv2",
 411         .irq_mask               = gic_eoimode1_mask_irq,
 412         .irq_unmask             = gic_unmask_irq,
 413         .irq_eoi                = gic_eoimode1_eoi_irq,
 414         .irq_set_type           = gic_set_type,
 415 #ifdef CONFIG_SMP
 416         .irq_set_affinity       = gic_set_affinity,
 417 #endif
 418         .irq_get_irqchip_state  = gic_irq_get_irqchip_state,
 419         .irq_set_irqchip_state  = gic_irq_set_irqchip_state,
 420         .irq_set_vcpu_affinity  = gic_irq_set_vcpu_affinity,
 421         .flags                  = IRQCHIP_SET_TYPE_MASKED |
 422                                   IRQCHIP_SKIP_SET_WAKE |
 423                                   IRQCHIP_MASK_ON_SUSPEND,
 424 };
 425
 426 void __init gic_cascade_irq(unsigned int gic_nr, unsigned int irq)
 427 {
 428         if (gic_nr >= MAX_GIC_NR)
 429                 BUG();
 430         irq_set_chained_handler_and_data(irq, gic_handle_cascade_irq,
 431                                          &gic_data[gic_nr]);
 432 }
 433
 434 static u8 gic_get_cpumask(struct gic_chip_data *gic)
 435 {
 436         void __iomem *base = gic_data_dist_base(gic);
 437         u32 mask, i;
 438
 439         for (i = mask = 0; i < 32; i += 4) {
 440                 mask = readl_relaxed(base + GIC_DIST_TARGET + i);
 441                 mask |= mask >> 16;
 442                 mask |= mask >> 8;
 443                 if (mask)
 444                         break;
 445         }
 446
 447         if (!mask && num_possible_cpus() > 1)
 448                 pr_crit("GIC CPU mask not found - kernel will fail to boot.\n");
 449
 450         return mask;
 451 }
 452
 453 static void gic_cpu_if_up(struct gic_chip_data *gic)
 454 {
 455         void __iomem *cpu_base = gic_data_cpu_base(gic);
 456         u32 bypass = 0;
 457         u32 mode = 0;
 458
 459         if (static_key_true(&supports_deactivate))
 460                 mode = GIC_CPU_CTRL_EOImodeNS;
 461
 462         /*
 463         * Preserve bypass disable bits to be written back later
 464         */
 465         bypass = readl(cpu_base + GIC_CPU_CTRL);
 466         bypass &= GICC_DIS_BYPASS_MASK;
 467
 468         writel_relaxed(bypass | mode | GICC_ENABLE, cpu_base + GIC_CPU_CTRL);
 469 }
 470
 471
 472 static void __init gic_dist_init(struct gic_chip_data *gic)
 473 {
 474         unsigned int i;
 475         u32 cpumask;
 476         unsigned int gic_irqs = gic->gic_irqs;
 477         void __iomem *base = gic_data_dist_base(gic);
 478
 479         writel_relaxed(GICD_DISABLE, base + GIC_DIST_CTRL);
 480
 481         /*
 482          * Set all global interrupts to this CPU only.
 483          */
 484         cpumask = gic_get_cpumask(gic);
 485         cpumask |= cpumask << 8;
 486         cpumask |= cpumask << 16;
 487         for (i = 32; i < gic_irqs; i += 4)
 488                 writel_relaxed(cpumask, base + GIC_DIST_TARGET + i * 4 / 4);
 489
 490         gic_dist_config(base, gic_irqs, NULL);
 491
 492         writel_relaxed(GICD_ENABLE, base + GIC_DIST_CTRL);
 493 }
 494
 495 static void gic_cpu_init(struct gic_chip_data *gic)
 496 {
 497         void __iomem *dist_base = gic_data_dist_base(gic);
 498         void __iomem *base = gic_data_cpu_base(gic);
 499         unsigned int cpu_mask, cpu = smp_processor_id();
 500         int i;
 501
 502         /*
 503          * Setting up the CPU map is only relevant for the primary GIC
 504          * because any nested/secondary GICs do not directly interface
 505          * with the CPU(s).
 506          */
 507         if (gic == &gic_data[0]) {
 508                 /*
 509                  * Get what the GIC says our CPU mask is.
 510                  */
 511                 BUG_ON(cpu >= NR_GIC_CPU_IF);
 512                 cpu_mask = gic_get_cpumask(gic);
 513                 gic_cpu_map[cpu] = cpu_mask;
 514
 515                 /*
 516                  * Clear our mask from the other map entries in case they're
 517                  * still undefined.
 518                  */
 519                 for (i = 0; i < NR_GIC_CPU_IF; i++)
 520                         if (i != cpu)
 521                                 gic_cpu_map[i] &= ~cpu_mask;
 522         }
 523
 524         gic_cpu_config(dist_base, NULL);
 525
 526         writel_relaxed(GICC_INT_PRI_THRESHOLD, base + GIC_CPU_PRIMASK);
 527         gic_cpu_if_up(gic);
 528 }
 529
 530 int gic_cpu_if_down(unsigned int gic_nr)
 531 {
 532         void __iomem *cpu_base;
 533         u32 val = 0;
 534
 535         if (gic_nr >= MAX_GIC_NR)
 536                 return -EINVAL;
 537
 538         cpu_base = gic_data_cpu_base(&gic_data[gic_nr]);
 539         val = readl(cpu_base + GIC_CPU_CTRL);
 540         val &= ~GICC_ENABLE;
 541         writel_relaxed(val, cpu_base + GIC_CPU_CTRL);
 542
 543         return 0;
 544 }
 545
 546 #ifdef CONFIG_CPU_PM
 547 /*
 548  * Saves the GIC distributor registers during suspend or idle.  Must be called
 549  * with interrupts disabled but before powering down the GIC.  After calling
 550  * this function, no interrupts will be delivered by the GIC, and another
 551  * platform-specific wakeup source must be enabled.
 552  */
 553 static void gic_dist_save(unsigned int gic_nr)
 554 {
 555         unsigned int gic_irqs;
 556         void __iomem *dist_base;
 557         int i;
 558
 559         if (gic_nr >= MAX_GIC_NR)
 560                 BUG();
 561
 562         gic_irqs = gic_data[gic_nr].gic_irqs;
 563         dist_base = gic_data_dist_base(&gic_data[gic_nr]);
 564
 565         if (!dist_base)
 566                 return;
 567
 568         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)
 569                 gic_data[gic_nr].saved_spi_conf[i] =
 570                         readl_relaxed(dist_base + GIC_DIST_CONFIG + i * 4);
 571
 572         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
 573                 gic_data[gic_nr].saved_spi_target[i] =
 574                         readl_relaxed(dist_base + GIC_DIST_TARGET + i * 4);
 575
 576         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)
 577                 gic_data[gic_nr].saved_spi_enable[i] =
 578                         readl_relaxed(dist_base + GIC_DIST_ENABLE_SET + i * 4);
 579
 580         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)
 581                 gic_data[gic_nr].saved_spi_active[i] =
 582                         readl_relaxed(dist_base + GIC_DIST_ACTIVE_SET + i * 4);
 583 }
 584
 585 /*
 586  * Restores the GIC distributor registers during resume or when coming out of
 587  * idle.  Must be called before enabling interrupts.  If a level interrupt
 588  * that occured while the GIC was suspended is still present, it will be
 589  * handled normally, but any edge interrupts that occured will not be seen by
 590  * the GIC and need to be handled by the platform-specific wakeup source.
 591  */
 592 static void gic_dist_restore(unsigned int gic_nr)
 593 {
 594         unsigned int gic_irqs;
 595         unsigned int i;
 596         void __iomem *dist_base;
 597
 598         if (gic_nr >= MAX_GIC_NR)
 599                 BUG();
 600
 601         gic_irqs = gic_data[gic_nr].gic_irqs;
 602         dist_base = gic_data_dist_base(&gic_data[gic_nr]);
 603
 604         if (!dist_base)
 605                 return;
 606
 607         writel_relaxed(GICD_DISABLE, dist_base + GIC_DIST_CTRL);
 608
 609         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)
 610                 writel_relaxed(gic_data[gic_nr].saved_spi_conf[i],
 611                         dist_base + GIC_DIST_CONFIG + i * 4);
 612
 613         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
 614                 writel_relaxed(GICD_INT_DEF_PRI_X4,
 615                         dist_base + GIC_DIST_PRI + i * 4);
 616
 617         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
 618                 writel_relaxed(gic_data[gic_nr].saved_spi_target[i],
 619                         dist_base + GIC_DIST_TARGET + i * 4);
 620
 621         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {
 622                 writel_relaxed(GICD_INT_EN_CLR_X32,
 623                         dist_base + GIC_DIST_ENABLE_CLEAR + i * 4);
 624                 writel_relaxed(gic_data[gic_nr].saved_spi_enable[i],
 625                         dist_base + GIC_DIST_ENABLE_SET + i * 4);
 626         }
 627
 628         for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {
 629                 writel_relaxed(GICD_INT_EN_CLR_X32,
 630                         dist_base + GIC_DIST_ACTIVE_CLEAR + i * 4);
 631                 writel_relaxed(gic_data[gic_nr].saved_spi_active[i],
 632                         dist_base + GIC_DIST_ACTIVE_SET + i * 4);
 633         }
 634
 635         writel_relaxed(GICD_ENABLE, dist_base + GIC_DIST_CTRL);
 636 }
 637
 638 static void gic_cpu_save(unsigned int gic_nr)
 639 {
 640         int i;
 641         u32 *ptr;
 642         void __iomem *dist_base;
 643         void __iomem *cpu_base;
 644
 645         if (gic_nr >= MAX_GIC_NR)
 646                 BUG();
 647
 648         dist_base = gic_data_dist_base(&gic_data[gic_nr]);
 649         cpu_base = gic_data_cpu_base(&gic_data[gic_nr]);
 650
 651         if (!dist_base || !cpu_base)
 652                 return;
 653
 654         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_enable);
 655         for (i = 0; i < DIV_ROUND_UP(32, 32); i++)
 656                 ptr[i] = readl_relaxed(dist_base + GIC_DIST_ENABLE_SET + i * 4);
 657
 658         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_active);
 659         for (i = 0; i < DIV_ROUND_UP(32, 32); i++)
 660                 ptr[i] = readl_relaxed(dist_base + GIC_DIST_ACTIVE_SET + i * 4);
 661
 662         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_conf);
 663         for (i = 0; i < DIV_ROUND_UP(32, 16); i++)
 664                 ptr[i] = readl_relaxed(dist_base + GIC_DIST_CONFIG + i * 4);
 665
 666 }
 667
 668 static void gic_cpu_restore(unsigned int gic_nr)
 669 {
 670         int i;
 671         u32 *ptr;
 672         void __iomem *dist_base;
 673         void __iomem *cpu_base;
 674
 675         if (gic_nr >= MAX_GIC_NR)
 676                 BUG();
 677
 678         dist_base = gic_data_dist_base(&gic_data[gic_nr]);
 679         cpu_base = gic_data_cpu_base(&gic_data[gic_nr]);
 680
 681         if (!dist_base || !cpu_base)
 682                 return;
 683
 684         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_enable);
 685         for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {
 686                 writel_relaxed(GICD_INT_EN_CLR_X32,
 687                                dist_base + GIC_DIST_ENABLE_CLEAR + i * 4);
 688                 writel_relaxed(ptr[i], dist_base + GIC_DIST_ENABLE_SET + i * 4);
 689         }
 690
 691         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_active);
 692         for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {
 693                 writel_relaxed(GICD_INT_EN_CLR_X32,
 694                                dist_base + GIC_DIST_ACTIVE_CLEAR + i * 4);
 695                 writel_relaxed(ptr[i], dist_base + GIC_DIST_ACTIVE_SET + i * 4);
 696         }
 697
 698         ptr = raw_cpu_ptr(gic_data[gic_nr].saved_ppi_conf);
 699         for (i = 0; i < DIV_ROUND_UP(32, 16); i++)
 700                 writel_relaxed(ptr[i], dist_base + GIC_DIST_CONFIG + i * 4);
 701
 702         for (i = 0; i < DIV_ROUND_UP(32, 4); i++)
 703                 writel_relaxed(GICD_INT_DEF_PRI_X4,
 704                                         dist_base + GIC_DIST_PRI + i * 4);
 705
 706         writel_relaxed(GICC_INT_PRI_THRESHOLD, cpu_base + GIC_CPU_PRIMASK);
 707         gic_cpu_if_up(&gic_data[gic_nr]);
 708 }
 709
 710 static int gic_notifier(struct notifier_block *self, unsigned long cmd, void *v)
 711 {
 712         int i;
 713
 714         for (i = 0; i < MAX_GIC_NR; i++) {
 715 #ifdef CONFIG_GIC_NON_BANKED
 716                 /* Skip over unused GICs */
 717                 if (!gic_data[i].get_base)
 718                         continue;
 719 #endif
 720                 switch (cmd) {
 721                 case CPU_PM_ENTER:
 722                         gic_cpu_save(i);
 723                         break;
 724                 case CPU_PM_ENTER_FAILED:
 725                 case CPU_PM_EXIT:
 726                         gic_cpu_restore(i);
 727                         break;
 728                 case CPU_CLUSTER_PM_ENTER:
 729                         gic_dist_save(i);
 730                         break;
 731                 case CPU_CLUSTER_PM_ENTER_FAILED:
 732                 case CPU_CLUSTER_PM_EXIT:
 733                         gic_dist_restore(i);
 734                         break;
 735                 }
 736         }
 737
 738         return NOTIFY_OK;
 739 }
 740
 741 static struct notifier_block gic_notifier_block = {
 742         .notifier_call = gic_notifier,
 743 };
 744
 745 static void __init gic_pm_init(struct gic_chip_data *gic)
 746 {
 747         gic->saved_ppi_enable = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,
 748                 sizeof(u32));
 749         BUG_ON(!gic->saved_ppi_enable);
 750
 751         gic->saved_ppi_active = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,
 752                 sizeof(u32));
 753         BUG_ON(!gic->saved_ppi_active);
 754
 755         gic->saved_ppi_conf = __alloc_percpu(DIV_ROUND_UP(32, 16) * 4,
 756                 sizeof(u32));
 757         BUG_ON(!gic->saved_ppi_conf);
 758
 759         if (gic == &gic_data[0])
 760                 cpu_pm_register_notifier(&gic_notifier_block);
 761 }
 762 #else
 763 static void __init gic_pm_init(struct gic_chip_data *gic)
 764 {
 765 }
 766 #endif
 767
 768 #ifdef CONFIG_SMP
 769 static void gic_raise_softirq(const struct cpumask *mask, unsigned int irq)
 770 {
 771         int cpu;
 772         unsigned long flags, map = 0;
 773
 774         raw_spin_lock_irqsave(&irq_controller_lock, flags);
 775
 776         /* Convert our logical CPU mask into a physical one. */
 777         for_each_cpu(cpu, mask)
 778                 map |= gic_cpu_map[cpu];
 779
 780         /*
 781          * Ensure that stores to Normal memory are visible to the
 782          * other CPUs before they observe us issuing the IPI.
 783          */
 784         dmb(ishst);
 785
 786         /* this always happens on GIC0 */
 787         writel_relaxed(map << 16 | irq, gic_data_dist_base(&gic_data[0]) + GIC_DIST_SOFTINT);
 788
 789         raw_spin_unlock_irqrestore(&irq_controller_lock, flags);
 790 }
 791 #endif
 792
 793 #ifdef CONFIG_BL_SWITCHER
 794 /*
 795  * gic_send_sgi - send a SGI directly to given CPU interface number
 796  *
 797  * cpu_id: the ID for the destination CPU interface
 798  * irq: the IPI number to send a SGI for
 799  */
 800 void gic_send_sgi(unsigned int cpu_id, unsigned int irq)
 801 {
 802         BUG_ON(cpu_id >= NR_GIC_CPU_IF);
 803         cpu_id = 1 << cpu_id;
 804         /* this always happens on GIC0 */
 805         writel_relaxed((cpu_id << 16) | irq, gic_data_dist_base(&gic_data[0]) + GIC_DIST_SOFTINT);
 806 }
 807
 808 /*
 809  * gic_get_cpu_id - get the CPU interface ID for the specified CPU
 810  *
 811  * @cpu: the logical CPU number to get the GIC ID for.
 812  *
 813  * Return the CPU interface ID for the given logical CPU number,
 814  * or -1 if the CPU number is too large or the interface ID is
 815  * unknown (more than one bit set).
 816  */
 817 int gic_get_cpu_id(unsigned int cpu)
 818 {
 819         unsigned int cpu_bit;
 820
 821         if (cpu >= NR_GIC_CPU_IF)
 822                 return -1;
 823         cpu_bit = gic_cpu_map[cpu];
 824         if (cpu_bit & (cpu_bit - 1))
 825                 return -1;
 826         return __ffs(cpu_bit);
 827 }
 828
 829 /*
 830  * gic_migrate_target - migrate IRQs to another CPU interface
 831  *
 832  * @new_cpu_id: the CPU target ID to migrate IRQs to
 833  *
 834  * Migrate all peripheral interrupts with a target matching the current CPU
 835  * to the interface corresponding to @new_cpu_id.  The CPU interface mapping
 836  * is also updated.  Targets to other CPU interfaces are unchanged.
 837  * This must be called with IRQs locally disabled.
 838  */
 839 void gic_migrate_target(unsigned int new_cpu_id)
 840 {
 841         unsigned int cur_cpu_id, gic_irqs, gic_nr = 0;
 842         void __iomem *dist_base;
 843         int i, ror_val, cpu = smp_processor_id();
 844         u32 val, cur_target_mask, active_mask;
 845
 846         if (gic_nr >= MAX_GIC_NR)
 847                 BUG();
 848
 849         dist_base = gic_data_dist_base(&gic_data[gic_nr]);
 850         if (!dist_base)
 851                 return;
 852         gic_irqs = gic_data[gic_nr].gic_irqs;
 853
 854         cur_cpu_id = __ffs(gic_cpu_map[cpu]);
 855         cur_target_mask = 0x01010101 << cur_cpu_id;
 856         ror_val = (cur_cpu_id - new_cpu_id) & 31;
 857
 858         raw_spin_lock(&irq_controller_lock);
 859
 860         /* Update the target interface for this logical CPU */
 861         gic_cpu_map[cpu] = 1 << new_cpu_id;
 862
 863         /*
 864          * Find all the peripheral interrupts targetting the current
 865          * CPU interface and migrate them to the new CPU interface.
 866          * We skip DIST_TARGET 0 to 7 as they are read-only.
 867          */
 868         for (i = 8; i < DIV_ROUND_UP(gic_irqs, 4); i++) {
 869                 val = readl_relaxed(dist_base + GIC_DIST_TARGET + i * 4);
 870                 active_mask = val & cur_target_mask;
 871                 if (active_mask) {
 872                         val &= ~active_mask;
 873                         val |= ror32(active_mask, ror_val);
 874                         writel_relaxed(val, dist_base + GIC_DIST_TARGET + i*4);
 875                 }
 876         }
 877
 878         raw_spin_unlock(&irq_controller_lock);
 879
 880         /*
 881          * Now let's migrate and clear any potential SGIs that might be
 882          * pending for us (cur_cpu_id).  Since GIC_DIST_SGI_PENDING_SET
 883          * is a banked register, we can only forward the SGI using
 884          * GIC_DIST_SOFTINT.  The original SGI source is lost but Linux
 885          * doesn't use that information anyway.
 886          *
 887          * For the same reason we do not adjust SGI source information
 888          * for previously sent SGIs by us to other CPUs either.
 889          */
 890         for (i = 0; i < 16; i += 4) {
 891                 int j;
 892                 val = readl_relaxed(dist_base + GIC_DIST_SGI_PENDING_SET + i);
 893                 if (!val)
 894                         continue;
 895                 writel_relaxed(val, dist_base + GIC_DIST_SGI_PENDING_CLEAR + i);
 896                 for (j = i; j < i + 4; j++) {
 897                         if (val & 0xff)
 898                                 writel_relaxed((1 << (new_cpu_id + 16)) | j,
 899                                                 dist_base + GIC_DIST_SOFTINT);
 900                         val >>= 8;
 901                 }
 902         }
 903 }
 904
 905 /*
 906  * gic_get_sgir_physaddr - get the physical address for the SGI register
 907  *
 908  * REturn the physical address of the SGI register to be used
 909  * by some early assembly code when the kernel is not yet available.
 910  */
 911 static unsigned long gic_dist_physaddr;
 912
 913 unsigned long gic_get_sgir_physaddr(void)
 914 {
 915         if (!gic_dist_physaddr)
 916                 return 0;
 917         return gic_dist_physaddr + GIC_DIST_SOFTINT;
 918 }
 919
 920 void __init gic_init_physaddr(struct device_node *node)
 921 {
 922         struct resource res;
 923         if (of_address_to_resource(node, 0, &res) == 0) {
 924                 gic_dist_physaddr = res.start;
 925                 pr_info("GIC physical location is %#lx\n", gic_dist_physaddr);
 926         }
 927 }
 928
 929 #else
 930 #define gic_init_physaddr(node)  do { } while (0)
 931 #endif
 932
 933 static int gic_irq_domain_map(struct irq_domain *d, unsigned int irq,
 934                                 irq_hw_number_t hw)
 935 {
 936         struct irq_chip *chip = &gic_chip;
 937
 938         if (static_key_true(&supports_deactivate)) {
 939                 if (d->host_data == (void *)&gic_data[0])
 940                         chip = &gic_eoimode1_chip;
 941         }
 942
 943         if (hw < 32) {
 944                 irq_set_percpu_devid(irq);
 945                 irq_domain_set_info(d, irq, hw, chip, d->host_data,
 946                                     handle_percpu_devid_irq, NULL, NULL);
 947                 irq_set_status_flags(irq, IRQ_NOAUTOEN);
 948         } else {
 949                 irq_domain_set_info(d, irq, hw, chip, d->host_data,
 950                                     handle_fasteoi_irq, NULL, NULL);
 951                 irq_set_probe(irq);
 952         }
 953         return 0;
 954 }
 955
 956 static void gic_irq_domain_unmap(struct irq_domain *d, unsigned int irq)
 957 {
 958 }
 959
 960 static int gic_irq_domain_translate(struct irq_domain *d,
 961                                     struct irq_fwspec *fwspec,
 962                                     unsigned long *hwirq,
 963                                     unsigned int *type)
 964 {
 965         if (is_of_node(fwspec->fwnode)) {
 966                 if (fwspec->param_count < 3)
 967                         return -EINVAL;
 968
 969                 /* Get the interrupt number and add 16 to skip over SGIs */
 970                 *hwirq = fwspec->param[1] + 16;
 971
 972                 /*
 973                  * For SPIs, we need to add 16 more to get the GIC irq
 974                  * ID number
 975                  */
 976                 if (!fwspec->param[0])
 977                         *hwirq += 16;
 978
 979                 *type = fwspec->param[2] & IRQ_TYPE_SENSE_MASK;
 980                 return 0;
 981         }
 982
 983         if (fwspec->fwnode->type == FWNODE_IRQCHIP) {
 984                 if(fwspec->param_count != 2)
 985                         return -EINVAL;
 986
 987                 *hwirq = fwspec->param[0];
 988                 *type = fwspec->param[1];
 989                 return 0;
 990         }
 991
 992         return -EINVAL;
 993 }
 994
 995 #ifdef CONFIG_SMP
 996 static int gic_secondary_init(struct notifier_block *nfb, unsigned long action,
 997                               void *hcpu)
 998 {
 999         if (action == CPU_STARTING || action == CPU_STARTING_FROZEN)
1000                 gic_cpu_init(&gic_data[0]);
1001         return NOTIFY_OK;
1002 }
1003
1004 /*
1005  * Notifier for enabling the GIC CPU interface. Set an arbitrarily high
1006  * priority because the GIC needs to be up before the ARM generic timers.
1007  */
1008 static struct notifier_block gic_cpu_notifier = {
1009         .notifier_call = gic_secondary_init,
1010         .priority = 100,
1011 };
1012 #endif
1013
1014 static int gic_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
1015                                 unsigned int nr_irqs, void *arg)
1016 {
1017         int i, ret;
1018         irq_hw_number_t hwirq;
1019         unsigned int type = IRQ_TYPE_NONE;
1020         struct irq_fwspec *fwspec = arg;
1021
1022         ret = gic_irq_domain_translate(domain, fwspec, &hwirq, &type);
1023         if (ret)
1024                 return ret;
1025
1026         for (i = 0; i < nr_irqs; i++)
1027                 gic_irq_domain_map(domain, virq + i, hwirq + i);
1028
1029         return 0;
1030 }
1031
1032 static const struct irq_domain_ops gic_irq_domain_hierarchy_ops = {
1033         .translate = gic_irq_domain_translate,
1034         .alloc = gic_irq_domain_alloc,
1035         .free = irq_domain_free_irqs_top,
1036 };
1037
1038 static const struct irq_domain_ops gic_irq_domain_ops = {
1039         .map = gic_irq_domain_map,
1040         .unmap = gic_irq_domain_unmap,
1041 };
1042
1043 static void __init __gic_init_bases(unsigned int gic_nr, int irq_start,
1044                            void __iomem *dist_base, void __iomem *cpu_base,
1045                            u32 percpu_offset, struct fwnode_handle *handle)
1046 {
1047         irq_hw_number_t hwirq_base;
1048         struct gic_chip_data *gic;
1049         int gic_irqs, irq_base, i;
1050
1051         BUG_ON(gic_nr >= MAX_GIC_NR);
1052
1053         gic_check_cpu_features();
1054
1055         gic = &gic_data[gic_nr];
1056 #ifdef CONFIG_GIC_NON_BANKED
1057         if (percpu_offset) { /* Frankein-GIC without banked registers... */
1058                 unsigned int cpu;
1059
1060                 gic->dist_base.percpu_base = alloc_percpu(void __iomem *);
1061                 gic->cpu_base.percpu_base = alloc_percpu(void __iomem *);
1062                 if (WARN_ON(!gic->dist_base.percpu_base ||
1063                             !gic->cpu_base.percpu_base)) {
1064                         free_percpu(gic->dist_base.percpu_base);
1065                         free_percpu(gic->cpu_base.percpu_base);
1066                         return;
1067                 }
1068
1069                 for_each_possible_cpu(cpu) {
1070                         u32 mpidr = cpu_logical_map(cpu);
1071                         u32 core_id = MPIDR_AFFINITY_LEVEL(mpidr, 0);
1072                         unsigned long offset = percpu_offset * core_id;
1073                         *per_cpu_ptr(gic->dist_base.percpu_base, cpu) = dist_base + offset;
1074                         *per_cpu_ptr(gic->cpu_base.percpu_base, cpu) = cpu_base + offset;
1075                 }
1076
1077                 gic_set_base_accessor(gic, gic_get_percpu_base);
1078         } else
1079 #endif
1080         {                       /* Normal, sane GIC... */
1081                 WARN(percpu_offset,
1082                      "GIC_NON_BANKED not enabled, ignoring %08x offset!",
1083                      percpu_offset);
1084                 gic->dist_base.common_base = dist_base;
1085                 gic->cpu_base.common_base = cpu_base;
1086                 gic_set_base_accessor(gic, gic_get_common_base);
1087         }
1088
1089         /*
1090          * Find out how many interrupts are supported.
1091          * The GIC only supports up to 1020 interrupt sources.
1092          */
1093         gic_irqs = readl_relaxed(gic_data_dist_base(gic) + GIC_DIST_CTR) & 0x1f;
1094         gic_irqs = (gic_irqs + 1) * 32;
1095         if (gic_irqs > 1020)
1096                 gic_irqs = 1020;
1097         gic->gic_irqs = gic_irqs;
1098
1099         if (handle) {           /* DT/ACPI */
1100                 gic->domain = irq_domain_create_linear(handle, gic_irqs,
1101                                                        &gic_irq_domain_hierarchy_ops,
1102                                                        gic);
1103         } else {                /* Legacy support */
1104                 /*
1105                  * For primary GICs, skip over SGIs.
1106                  * For secondary GICs, skip over PPIs, too.
1107                  */
1108                 if (gic_nr == 0 && (irq_start & 31) > 0) {
1109                         hwirq_base = 16;
1110                         if (irq_start != -1)
1111                                 irq_start = (irq_start & ~31) + 16;
1112                 } else {
1113                         hwirq_base = 32;
1114                 }
1115
1116                 gic_irqs -= hwirq_base; /* calculate # of irqs to allocate */
1117
1118                 irq_base = irq_alloc_descs(irq_start, 16, gic_irqs,
1119                                            numa_node_id());
1120                 if (IS_ERR_VALUE(irq_base)) {
1121                         WARN(1, "Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
1122                              irq_start);
1123                         irq_base = irq_start;
1124                 }
1125
1126                 gic->domain = irq_domain_add_legacy(NULL, gic_irqs, irq_base,
1127                                         hwirq_base, &gic_irq_domain_ops, gic);
1128         }
1129
1130         if (WARN_ON(!gic->domain))
1131                 return;
1132
1133         if (gic_nr == 0) {
1134                 /*
1135                  * Initialize the CPU interface map to all CPUs.
1136                  * It will be refined as each CPU probes its ID.
1137                  * This is only necessary for the primary GIC.
1138                  */
1139                 for (i = 0; i < NR_GIC_CPU_IF; i++)
1140                         gic_cpu_map[i] = 0xff;
1141 #ifdef CONFIG_SMP
1142                 set_smp_cross_call(gic_raise_softirq);
1143                 register_cpu_notifier(&gic_cpu_notifier);
1144 #endif
1145                 set_handle_irq(gic_handle_irq);
1146                 if (static_key_true(&supports_deactivate))
1147                         pr_info("GIC: Using split EOI/Deactivate mode\n");
1148         }
1149
1150         gic_dist_init(gic);
1151         gic_cpu_init(gic);
1152         gic_pm_init(gic);
1153 }
1154
1155 void __init gic_init(unsigned int gic_nr, int irq_start,
1156                      void __iomem *dist_base, void __iomem *cpu_base)
1157 {
1158         /*
1159          * Non-DT/ACPI systems won't run a hypervisor, so let's not
1160          * bother with these...
1161          */
1162         static_key_slow_dec(&supports_deactivate);
1163         __gic_init_bases(gic_nr, irq_start, dist_base, cpu_base, 0, NULL);
1164 }
1165
1166 #ifdef CONFIG_OF
1167 static int gic_cnt __initdata;
1168
1169 static bool gic_check_eoimode(struct device_node *node, void __iomem **base)
1170 {
1171         struct resource cpuif_res;
1172
1173         of_address_to_resource(node, 1, &cpuif_res);
1174
1175         if (!is_hyp_mode_available())
1176                 return false;
1177         if (resource_size(&cpuif_res) < SZ_8K)
1178                 return false;
1179         if (resource_size(&cpuif_res) == SZ_128K) {
1180                 u32 val_low, val_high;
1181
1182                 /*
1183                  * Verify that we have the first 4kB of a GIC400
1184                  * aliased over the first 64kB by checking the
1185                  * GICC_IIDR register on both ends.
1186                  */
1187                 val_low = readl_relaxed(*base + GIC_CPU_IDENT);
1188                 val_high = readl_relaxed(*base + GIC_CPU_IDENT + 0xf000);
1189                 if ((val_low & 0xffff0fff) != 0x0202043B ||
1190                     val_low != val_high)
1191                         return false;
1192
1193                 /*
1194                  * Move the base up by 60kB, so that we have a 8kB
1195                  * contiguous region, which allows us to use GICC_DIR
1196                  * at its normal offset. Please pass me that bucket.
1197                  */
1198                 *base += 0xf000;
1199                 cpuif_res.start += 0xf000;
1200                 pr_warn("GIC: Adjusting CPU interface base to %pa",
1201                         &cpuif_res.start);
1202         }
1203
1204         return true;
1205 }
1206
1207 static int __init
1208 gic_of_init(struct device_node *node, struct device_node *parent)
1209 {
1210         void __iomem *cpu_base;
1211         void __iomem *dist_base;
1212         u32 percpu_offset;
1213         int irq;
1214
1215         if (WARN_ON(!node))
1216                 return -ENODEV;
1217
1218         dist_base = of_iomap(node, 0);
1219         WARN(!dist_base, "unable to map gic dist registers\n");
1220
1221         cpu_base = of_iomap(node, 1);
1222         WARN(!cpu_base, "unable to map gic cpu registers\n");
1223
1224         /*
1225          * Disable split EOI/Deactivate if either HYP is not available
1226          * or the CPU interface is too small.
1227          */
1228         if (gic_cnt == 0 && !gic_check_eoimode(node, &cpu_base))
1229                 static_key_slow_dec(&supports_deactivate);
1230
1231         if (of_property_read_u32(node, "cpu-offset", &percpu_offset))
1232                 percpu_offset = 0;
1233
1234         __gic_init_bases(gic_cnt, -1, dist_base, cpu_base, percpu_offset,
1235                          &node->fwnode);
1236         if (!gic_cnt)
1237                 gic_init_physaddr(node);
1238
1239         if (parent) {
1240                 irq = irq_of_parse_and_map(node, 0);
1241                 gic_cascade_irq(gic_cnt, irq);
1242         }
1243
1244         if (IS_ENABLED(CONFIG_ARM_GIC_V2M))
1245                 gicv2m_of_init(node, gic_data[gic_cnt].domain);
1246
1247         gic_cnt++;
1248         return 0;
1249 }
1250 IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
1251 IRQCHIP_DECLARE(arm11mp_gic, "arm,arm11mp-gic", gic_of_init);
1252 IRQCHIP_DECLARE(arm1176jzf_dc_gic, "arm,arm1176jzf-devchip-gic", gic_of_init);
1253 IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
1254 IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
1255 IRQCHIP_DECLARE(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init);
1256 IRQCHIP_DECLARE(msm_8660_qgic, "qcom,msm-8660-qgic", gic_of_init);
1257 IRQCHIP_DECLARE(msm_qgic2, "qcom,msm-qgic2", gic_of_init);
1258 IRQCHIP_DECLARE(pl390, "arm,pl390", gic_of_init);
1259
1260 #endif
1261
1262 #ifdef CONFIG_ACPI
1263 static phys_addr_t cpu_phy_base __initdata;
1264
1265 static int __init
1266 gic_acpi_parse_madt_cpu(struct acpi_subtable_header *header,
1267                         const unsigned long end)
1268 {
1269         struct acpi_madt_generic_interrupt *processor;
1270         phys_addr_t gic_cpu_base;
1271         static int cpu_base_assigned;
1272
1273         processor = (struct acpi_madt_generic_interrupt *)header;
1274
1275         if (BAD_MADT_GICC_ENTRY(processor, end))
1276                 return -EINVAL;
1277
1278         /*
1279          * There is no support for non-banked GICv1/2 register in ACPI spec.
1280          * All CPU interface addresses have to be the same.
1281          */
1282         gic_cpu_base = processor->base_address;
1283         if (cpu_base_assigned && gic_cpu_base != cpu_phy_base)
1284                 return -EINVAL;
1285
1286         cpu_phy_base = gic_cpu_base;
1287         cpu_base_assigned = 1;
1288         return 0;
1289 }
1290
1291 /* The things you have to do to just *count* something... */
1292 static int __init acpi_dummy_func(struct acpi_subtable_header *header,
1293                                   const unsigned long end)
1294 {
1295         return 0;
1296 }
1297
1298 static bool __init acpi_gic_redist_is_present(void)
1299 {
1300         return acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR,
1301                                      acpi_dummy_func, 0) > 0;
1302 }
1303
1304 static bool __init gic_validate_dist(struct acpi_subtable_header *header,
1305                                      struct acpi_probe_entry *ape)
1306 {
1307         struct acpi_madt_generic_distributor *dist;
1308         dist = (struct acpi_madt_generic_distributor *)header;
1309
1310         return (dist->version == ape->driver_data &&
1311                 (dist->version != ACPI_MADT_GIC_VERSION_NONE ||
1312                  !acpi_gic_redist_is_present()));
1313 }
1314
1315 #define ACPI_GICV2_DIST_MEM_SIZE        (SZ_4K)
1316 #define ACPI_GIC_CPU_IF_MEM_SIZE        (SZ_8K)
1317
1318 static int __init gic_v2_acpi_init(struct acpi_subtable_header *header,
1319                                    const unsigned long end)
1320 {
1321         struct acpi_madt_generic_distributor *dist;
1322         void __iomem *cpu_base, *dist_base;
1323         struct fwnode_handle *domain_handle;
1324         int count;
1325
1326         /* Collect CPU base addresses */
1327         count = acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
1328                                       gic_acpi_parse_madt_cpu, 0);
1329         if (count <= 0) {
1330                 pr_err("No valid GICC entries exist\n");
1331                 return -EINVAL;
1332         }
1333
1334         cpu_base = ioremap(cpu_phy_base, ACPI_GIC_CPU_IF_MEM_SIZE);
1335         if (!cpu_base) {
1336                 pr_err("Unable to map GICC registers\n");
1337                 return -ENOMEM;
1338         }
1339
1340         dist = (struct acpi_madt_generic_distributor *)header;
1341         dist_base = ioremap(dist->base_address, ACPI_GICV2_DIST_MEM_SIZE);
1342         if (!dist_base) {
1343                 pr_err("Unable to map GICD registers\n");
1344                 iounmap(cpu_base);
1345                 return -ENOMEM;
1346         }
1347
1348         /*
1349          * Disable split EOI/Deactivate if HYP is not available. ACPI
1350          * guarantees that we'll always have a GICv2, so the CPU
1351          * interface will always be the right size.
1352          */
1353         if (!is_hyp_mode_available())
1354                 static_key_slow_dec(&supports_deactivate);
1355
1356         /*
1357          * Initialize GIC instance zero (no multi-GIC support).
1358          */
1359         domain_handle = irq_domain_alloc_fwnode(dist_base);
1360         if (!domain_handle) {
1361                 pr_err("Unable to allocate domain handle\n");
1362                 iounmap(cpu_base);
1363                 iounmap(dist_base);
1364                 return -ENOMEM;
1365         }
1366
1367         __gic_init_bases(0, -1, dist_base, cpu_base, 0, domain_handle);
1368
1369         acpi_set_irq_model(ACPI_IRQ_MODEL_GIC, domain_handle);
1370         return 0;
1371 }
1372 IRQCHIP_ACPI_DECLARE(gic_v2, ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR,
1373                      gic_validate_dist, ACPI_MADT_GIC_VERSION_V2,
1374                      gic_v2_acpi_init);
1375 IRQCHIP_ACPI_DECLARE(gic_v2_maybe, ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR,
1376                      gic_validate_dist, ACPI_MADT_GIC_VERSION_NONE,
1377                      gic_v2_acpi_init);
1378 #endif