Release 4.7 drivers/irqchip/irq-gic.c

Directory: drivers/irqchip
/*
 *  Copyright (C) 2002 ARM Limited, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Interrupt architecture for the GIC:
 *
 * o There is one Interrupt Distributor, which receives interrupts
 *   from system devices and sends them to the Interrupt Controllers.
 *
 * o There is one CPU Interface per CPU, which sends interrupts sent
 *   by the Distributor, and interrupts generated locally, to the
 *   associated CPU. The base address of the CPU interface is usually
 *   aliased so that the same address points to different chips depending
 *   on the CPU it is accessed from.
 *
 * Note that IRQs 0-31 are special - they are local to each CPU.
 * As such, the enable set/clear, pending set/clear and active bit
 * registers are banked per-cpu for these sources.
 */
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/smp.h>
#include <linux/cpu.h>
#include <linux/cpu_pm.h>
#include <linux/cpumask.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/acpi.h>
#include <linux/irqdomain.h>
#include <linux/interrupt.h>
#include <linux/percpu.h>
#include <linux/slab.h>
#include <linux/irqchip.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/irqchip/arm-gic.h>

#include <asm/cputype.h>
#include <asm/irq.h>
#include <asm/exception.h>
#include <asm/smp_plat.h>
#include <asm/virt.h>

#include "irq-gic-common.h"

#ifdef CONFIG_ARM64
#include <asm/cpufeature.h>



static void gic_check_cpu_features(void)
{
	WARN_TAINT_ONCE(this_cpu_has_cap(ARM64_HAS_SYSREG_GIC_CPUIF),
			TAINT_CPU_OUT_OF_SPEC,
			"GICv3 system registers enabled, broken firmware!\n");
}
Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%

#else

#define gic_check_cpu_features()	do { } while(0)
#endif


union gic_base {
	
void __iomem *common_base;
	
void __percpu * __iomem *percpu_base;
};


struct gic_chip_data {
	
struct irq_chip chip;
	
union gic_base dist_base;
	
union gic_base cpu_base;
	
void __iomem *raw_dist_base;
	
void __iomem *raw_cpu_base;
	
u32 percpu_offset;
#ifdef CONFIG_CPU_PM
	
u32 saved_spi_enable[DIV_ROUND_UP(1020, 32)];
	
u32 saved_spi_active[DIV_ROUND_UP(1020, 32)];
	
u32 saved_spi_conf[DIV_ROUND_UP(1020, 16)];
	
u32 saved_spi_target[DIV_ROUND_UP(1020, 4)];
	
u32 __percpu *saved_ppi_enable;
	
u32 __percpu *saved_ppi_active;
	
u32 __percpu *saved_ppi_conf;
#endif
	
struct irq_domain *domain;
	
unsigned int gic_irqs;
#ifdef CONFIG_GIC_NON_BANKED
	
void __iomem *(*get_base)(union gic_base *);
#endif
};

static DEFINE_RAW_SPINLOCK(irq_controller_lock);

/*
 * The GIC mapping of CPU interfaces does not necessarily match
 * the logical CPU numbering.  Let's use a mapping as returned
 * by the GIC itself.
 */

#define NR_GIC_CPU_IF 8

static u8 gic_cpu_map[NR_GIC_CPU_IF] __read_mostly;


static struct static_key supports_deactivate = STATIC_KEY_INIT_TRUE;


static struct gic_chip_data gic_data[CONFIG_ARM_GIC_MAX_NR] __read_mostly;


static struct gic_kvm_info gic_v2_kvm_info;

#ifdef CONFIG_GIC_NON_BANKED


static void __iomem *gic_get_percpu_base(union gic_base *base)
{
	return raw_cpu_read(*base->percpu_base);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 20 90.91% 1 33.33%
christoph lameter christoph lameter 2 9.09% 2 66.67%
Total 22 100.00% 3 100.00%



static void __iomem *gic_get_common_base(union gic_base *base)
{
	return base->common_base;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static inline void __iomem *gic_data_dist_base(struct gic_chip_data *data)
{
	return data->get_base(&data->dist_base);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static inline void __iomem *gic_data_cpu_base(struct gic_chip_data *data)
{
	return data->get_base(&data->cpu_base);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


static inline void gic_set_base_accessor(struct gic_chip_data *data,
					 void __iomem *(*f)(union gic_base *))
{
	data->get_base = f;
}
#else

#define gic_data_dist_base(d)	((d)->dist_base.common_base)

#define gic_data_cpu_base(d)	((d)->cpu_base.common_base)

#define gic_set_base_accessor(d, f)
#endif



static inline void __iomem *gic_dist_base(struct irq_data *d)
{
	struct gic_chip_data *gic_data = irq_data_get_irq_chip_data(d);
	return gic_data_dist_base(gic_data);
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 15 50.00% 1 25.00%
russell king russell king 6 20.00% 1 25.00%
lennert buytenhek lennert buytenhek 6 20.00% 1 25.00%
marc zyngier marc zyngier 3 10.00% 1 25.00%
Total 30 100.00% 4 100.00%



static inline void __iomem *gic_cpu_base(struct irq_data *d)
{
	struct gic_chip_data *gic_data = irq_data_get_irq_chip_data(d);
	return gic_data_cpu_base(gic_data);
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 15 50.00% 1 25.00%
lennert buytenhek lennert buytenhek 6 20.00% 1 25.00%
russell king russell king 6 20.00% 1 25.00%
marc zyngier marc zyngier 3 10.00% 1 25.00%
Total 30 100.00% 4 100.00%



static inline unsigned int gic_irq(struct irq_data *d)
{
	return d->hwirq;
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 10 55.56% 1 25.00%
lennert buytenhek lennert buytenhek 6 33.33% 1 25.00%
thomas gleixner thomas gleixner 1 5.56% 1 25.00%
rob herring rob herring 1 5.56% 1 25.00%
Total 18 100.00% 4 100.00%



static inline bool cascading_gic_irq(struct irq_data *d)
{
	void *data = irq_data_get_irq_handler_data(d);

	/*
         * If handler_data is set, this is a cascading interrupt, and
         * it cannot possibly be forwarded.
         */
	return data != NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 23 85.19% 1 50.00%
thomas gleixner thomas gleixner 4 14.81% 1 50.00%
Total 27 100.00% 2 100.00%

/*
 * Routines to acknowledge, disable and enable interrupts
 */


static void gic_poke_irq(struct irq_data *d, u32 offset)
{
	u32 mask = 1 << (gic_irq(d) % 32);
	writel_relaxed(mask, gic_dist_base(d) + offset + (gic_irq(d) / 32) * 4);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 25 49.02% 2 33.33%
russell king russell king 16 31.37% 1 16.67%
lennert buytenhek lennert buytenhek 5 9.80% 1 16.67%
rob herring rob herring 3 5.88% 1 16.67%
thomas gleixner thomas gleixner 2 3.92% 1 16.67%
Total 51 100.00% 6 100.00%



static int gic_peek_irq(struct irq_data *d, u32 offset)
{
	u32 mask = 1 << (gic_irq(d) % 32);
	return !!(readl_relaxed(gic_dist_base(d) + offset + (gic_irq(d) / 32) * 4) & mask);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 38 67.86% 1 25.00%
russell king russell king 11 19.64% 1 25.00%
catalin marinas catalin marinas 5 8.93% 1 25.00%
lennert buytenhek lennert buytenhek 2 3.57% 1 25.00%
Total 56 100.00% 4 100.00%



static void gic_mask_irq(struct irq_data *d)
{
	gic_poke_irq(d, GIC_DIST_ENABLE_CLEAR);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 16 88.89% 1 50.00%
russell king russell king 2 11.11% 1 50.00%
Total 18 100.00% 2 100.00%



static void gic_eoimode1_mask_irq(struct irq_data *d)
{
	gic_mask_irq(d);
	/*
         * When masking a forwarded interrupt, make sure it is
         * deactivated as well.
         *
         * This ensures that an interrupt that is getting
         * disabled/masked will not get "stuck", because there is
         * noone to deactivate it (guest is being terminated).
         */
	if (irqd_is_forwarded_to_vcpu(d))
		gic_poke_irq(d, GIC_DIST_ACTIVE_CLEAR);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 30 96.77% 2 66.67%
thomas gleixner thomas gleixner 1 3.23% 1 33.33%
Total 31 100.00% 3 100.00%



static void gic_unmask_irq(struct irq_data *d)
{
	gic_poke_irq(d, GIC_DIST_ENABLE_SET);
}

Contributors
Person Tokens Prop Commits CommitProp
russell king russell king 10 55.56% 1 25.00%
lennert buytenhek lennert buytenhek 5 27.78% 1 25.00%
marc zyngier marc zyngier 2 11.11% 1 25.00%
catalin marinas catalin marinas 1 5.56% 1 25.00%
Total 18 100.00% 4 100.00%



static void gic_eoi_irq(struct irq_data *d)
{
	writel_relaxed(gic_irq(d), gic_cpu_base(d) + GIC_CPU_EOI);
}

Contributors
Person Tokens Prop Commits CommitProp
will deacon will deacon 25 96.15% 1 50.00%
santosh shilimkar santosh shilimkar 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%



static void gic_eoimode1_eoi_irq(struct irq_data *d)
{
	/* Do not deactivate an IRQ forwarded to a vcpu. */
	if (irqd_is_forwarded_to_vcpu(d))
		return;

	writel_relaxed(gic_irq(d), gic_cpu_base(d) + GIC_CPU_DEACTIVATE);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 34 97.14% 2 66.67%
thomas gleixner thomas gleixner 1 2.86% 1 33.33%
Total 35 100.00% 3 100.00%



static int gic_irq_set_irqchip_state(struct irq_data *d,
				     enum irqchip_irq_state which, bool val)
{
	u32 reg;

	switch (which) {
	case IRQCHIP_STATE_PENDING:
		reg = val ? GIC_DIST_PENDING_SET : GIC_DIST_PENDING_CLEAR;
		break;

	case IRQCHIP_STATE_ACTIVE:
		reg = val ? GIC_DIST_ACTIVE_SET : GIC_DIST_ACTIVE_CLEAR;
		break;

	case IRQCHIP_STATE_MASKED:
		reg = val ? GIC_DIST_ENABLE_CLEAR : GIC_DIST_ENABLE_SET;
		break;

	default:
		return -EINVAL;
	}

	gic_poke_irq(d, reg);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 78 100.00% 1 100.00%
Total 78 100.00% 1 100.00%



static int gic_irq_get_irqchip_state(struct irq_data *d,
				      enum irqchip_irq_state which, bool *val)
{
	switch (which) {
	case IRQCHIP_STATE_PENDING:
		*val = gic_peek_irq(d, GIC_DIST_PENDING_SET);
		break;

	case IRQCHIP_STATE_ACTIVE:
		*val = gic_peek_irq(d, GIC_DIST_ACTIVE_SET);
		break;

	case IRQCHIP_STATE_MASKED:
		*val = !gic_peek_irq(d, GIC_DIST_ENABLE_SET);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 76 100.00% 1 100.00%
Total 76 100.00% 1 100.00%



static int gic_set_type(struct irq_data *d, unsigned int type)
{
	void __iomem *base = gic_dist_base(d);
	unsigned int gicirq = gic_irq(d);

	/* Interrupt configuration for SGIs can't be changed */
	if (gicirq < 16)
		return -EINVAL;

	/* SPIs have restrictions on the supported types */
	if (gicirq >= 32 && type != IRQ_TYPE_LEVEL_HIGH &&
			    type != IRQ_TYPE_EDGE_RISING)
		return -EINVAL;

	return gic_configure_irq(gicirq, type, base, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
rabin vincent rabin vincent 58 76.32% 1 16.67%
lennert buytenhek lennert buytenhek 6 7.89% 1 16.67%
liviu dudau liviu dudau 5 6.58% 1 16.67%
marc zyngier marc zyngier 5 6.58% 2 33.33%
santosh shilimkar santosh shilimkar 2 2.63% 1 16.67%
Total 76 100.00% 6 100.00%



static int gic_irq_set_vcpu_affinity(struct irq_data *d, void *vcpu)
{
	/* Only interrupts on the primary GIC can be forwarded to a vcpu. */
	if (cascading_gic_irq(d))
		return -EINVAL;

	if (vcpu)
		irqd_set_forwarded_to_vcpu(d);
	else
		irqd_clr_forwarded_to_vcpu(d);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 32 71.11% 1 50.00%
thomas gleixner thomas gleixner 13 28.89% 1 50.00%
Total 45 100.00% 2 100.00%

#ifdef CONFIG_SMP


static int gic_set_affinity(struct irq_data *d, const struct cpumask *mask_val,
			    bool force)
{
	void __iomem *reg = gic_dist_base(d) + GIC_DIST_TARGET + (gic_irq(d) & ~3);
	unsigned int cpu, shift = (gic_irq(d) % 4) * 8;
	u32 val, mask, bit;
	unsigned long flags;

	if (!force)
		cpu = cpumask_any_and(mask_val, cpu_online_mask);
	else
		cpu = cpumask_first(mask_val);

	if (cpu >= NR_GIC_CPU_IF || cpu >= nr_cpu_ids)
		return -EINVAL;

	raw_spin_lock_irqsave(&irq_controller_lock, flags);
	mask = 0xff << shift;
	bit = gic_cpu_map[cpu] << shift;
	val = readl_relaxed(reg) & ~mask;
	writel_relaxed(val | bit, reg);
	raw_spin_unlock_irqrestore(&irq_controller_lock, flags);

	return IRQ_SET_MASK_OK_DONE;
}
Contributors
Person Tokens Prop Commits CommitProp
russell king russell king 78 49.06% 3 18.75%
thomas gleixner thomas gleixner 30 18.87% 2 12.50%
marc zyngier marc zyngier 11 6.92% 2 12.50%
lennert buytenhek lennert buytenhek 10 6.29% 1 6.25%
nicolas pitre nicolas pitre 10 6.29% 2 12.50%
catalin marinas catalin marinas 5 3.14% 1 6.25%
rusty russell rusty russell 4 2.52% 1 6.25%
chao xie chao xie 3 1.89% 1 6.25%
yinghai lu yinghai lu 3 1.89% 1 6.25%
rob herring rob herring 3 1.89% 1 6.25%
santosh shilimkar santosh shilimkar 2 1.26% 1 6.25%
Total 159 100.00% 16 100.00%

#endif



static void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
{
	u32 irqstat, irqnr;
	struct gic_chip_data *gic = &gic_data[0];
	void __iomem *cpu_base = gic_data_cpu_base(gic);

	do {
		irqstat = readl_relaxed(cpu_base + GIC_CPU_INTACK);
		irqnr = irqstat & GICC_IAR_INT_ID_MASK;

		if (likely(irqnr > 15 && irqnr < 1020)) {
			if (static_key_true(&supports_deactivate))
				writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
			handle_domain_irq(gic->domain, irqnr, regs);
			continue;
		}
		if (irqnr < 16) {
			writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
			if (static_key_true(&supports_deactivate))
				writel_relaxed(irqstat, cpu_base + GIC_CPU_DEACTIVATE);
#ifdef CONFIG_SMP
			/*
                         * Ensure any shared data written by the CPU sending
                         * the IPI is read after we've read the ACK register
                         * on the GIC.
                         *
                         * Pairs with the write barrier in gic_raise_softirq
                         */
			smp_rmb();
			handle_IPI(irqnr, regs);
#endif
			continue;
		}
		break;
	} while (1);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 151 96.18% 4 57.14%
will deacon will deacon 4 2.55% 1 14.29%
haojian zhuang haojian zhuang 1 0.64% 1 14.29%
rob herring rob herring 1 0.64% 1 14.29%
Total 157 100.00% 7 100.00%



static void gic_handle_cascade_irq(struct irq_desc *desc)
{
	struct gic_chip_data *chip_data = irq_desc_get_handler_data(desc);
	struct irq_chip *chip = irq_desc_get_chip(desc);
	unsigned int cascade_irq, gic_irq;
	unsigned long status;

	chained_irq_enter(chip, desc);

	raw_spin_lock(&irq_controller_lock);
	status = readl_relaxed(gic_data_cpu_base(chip_data) + GIC_CPU_INTACK);
	raw_spin_unlock(&irq_controller_lock);

	gic_irq = (status & GICC_IAR_INT_ID_MASK);
	if (gic_irq == GICC_INT_SPURIOUS)
		goto out;

	cascade_irq = irq_find_mapping(chip_data->domain, gic_irq);
	if (unlikely(gic_irq < 32 || gic_irq > 1020))
		handle_bad_irq(desc);
	else
		generic_handle_irq(cascade_irq);

 out:
	chained_irq_exit(chip, desc);
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 89 66.92% 2 16.67%
russell king russell king 18 13.53% 1 8.33%
will deacon will deacon 6 4.51% 1 8.33%
rob herring rob herring 5 3.76% 1 8.33%
jiang liu jiang liu 4 3.01% 1 8.33%
marc zyngier marc zyngier 3 2.26% 1 8.33%
thomas gleixner thomas gleixner 2 1.50% 1 8.33%
lennert buytenhek lennert buytenhek 2 1.50% 1 8.33%
feng kan feng kan 2 1.50% 1 8.33%
santosh shilimkar santosh shilimkar 1 0.75% 1 8.33%
grant likely grant likely 1 0.75% 1 8.33%
Total 133 100.00% 12 100.00%


static struct irq_chip gic_chip = {
	.irq_mask		= gic_mask_irq,
	.irq_unmask		= gic_unmask_irq,
	.irq_eoi		= gic_eoi_irq,
	.irq_set_type		= gic_set_type,
	.irq_get_irqchip_state	= gic_irq_get_irqchip_state,
	.irq_set_irqchip_state	= gic_irq_set_irqchip_state,
	.flags			= IRQCHIP_SET_TYPE_MASKED |
				  IRQCHIP_SKIP_SET_WAKE |
				  IRQCHIP_MASK_ON_SUSPEND,
};



void __init gic_cascade_irq(unsigned int gic_nr, unsigned int irq)
{
	BUG_ON(gic_nr >= CONFIG_ARM_GIC_MAX_NR);
	irq_set_chained_handler_and_data(irq, gic_handle_cascade_irq,
					 &gic_data[gic_nr]);
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 27 79.41% 1 33.33%
linus walleij linus walleij 4 11.76% 1 33.33%
thomas gleixner thomas gleixner 3 8.82% 1 33.33%
Total 34 100.00% 3 100.00%



static u8 gic_get_cpumask(struct gic_chip_data *gic)
{
	void __iomem *base = gic_data_dist_base(gic);
	u32 mask, i;

	for (i = mask = 0; i < 32; i += 4) {
		mask = readl_relaxed(base + GIC_DIST_TARGET + i);
		mask |= mask >> 16;
		mask |= mask >> 8;
		if (mask)
			break;
	}

	if (!mask && num_possible_cpus() > 1)
		pr_crit("GIC CPU mask not found - kernel will fail to boot.\n");

	return mask;
}

Contributors
Person Tokens Prop Commits CommitProp
russell king russell king 85 94.44% 1 50.00%
stephen boyd stephen boyd 5 5.56% 1 50.00%
Total 90 100.00% 2 100.00%



static void gic_cpu_if_up(struct gic_chip_data *gic)
{
	void __iomem *cpu_base = gic_data_cpu_base(gic);
	u32 bypass = 0;
	u32 mode = 0;

	if (gic == &gic_data[0] && static_key_true(&supports_deactivate))
		mode = GIC_CPU_CTRL_EOImodeNS;

	/*
        * Preserve bypass disable bits to be written back later
        */
	bypass = readl(cpu_base + GIC_CPU_CTRL);
	bypass &= GICC_DIS_BYPASS_MASK;

	writel_relaxed(bypass | mode | GICC_ENABLE, cpu_base + GIC_CPU_CTRL);
}


Contributors
Person Tokens Prop Commits CommitProp
feng kan feng kan 46 58.97% 1 25.00%
marc zyngier marc zyngier 19 24.36% 1 25.00%
jon hunter jon hunter 13 16.67% 2 50.00%
Total 78 100.00% 4 100.00%



static void __init gic_dist_init(struct gic_chip_data *gic)
{
	unsigned int i;
	u32 cpumask;
	unsigned int gic_irqs = gic->gic_irqs;
	void __iomem *base = gic_data_dist_base(gic);

	writel_relaxed(GICD_DISABLE, base + GIC_DIST_CTRL);

	/*
         * Set all global interrupts to this CPU only.
         */
	cpumask = gic_get_cpumask(gic);
	cpumask |= cpumask << 8;
	cpumask |= cpumask << 16;
	for (i = 32; i < gic_irqs; i += 4)
		writel_relaxed(cpumask, base + GIC_DIST_TARGET + i * 4 / 4);

	gic_dist_config(base, gic_irqs, NULL);

	writel_relaxed(GICD_ENABLE, base + GIC_DIST_CTRL);
}

Contributors
Person Tokens Prop Commits CommitProp
russell king russell king 84 74.34% 4 33.33%
rob herring rob herring 8 7.08% 1 8.33%
marc zyngier marc zyngier 6 5.31% 2 16.67%
nicolas pitre nicolas pitre 5 4.42% 1 8.33%
will deacon will deacon 3 2.65% 1 8.33%
santosh shilimkar santosh shilimkar 3 2.65% 1 8.33%
feng kan feng kan 2 1.77% 1 8.33%
pawel moll pawel moll 2 1.77% 1 8.33%
Total 113 100.00% 12 100.00%



static int gic_cpu_init(struct gic_chip_data *gic)
{
	void __iomem *dist_base = gic_data_dist_base(gic);
	void __iomem *base = gic_data_cpu_base(gic);
	unsigned int cpu_mask, cpu = smp_processor_id();
	int i;

	/*
         * Setting up the CPU map is only relevant for the primary GIC
         * because any nested/secondary GICs do not directly interface
         * with the CPU(s).
         */
	if (gic == &gic_data[0]) {
		/*
                 * Get what the GIC says our CPU mask is.
                 */
		if (WARN_ON(cpu >= NR_GIC_CPU_IF))
			return -EINVAL;

		gic_check_cpu_features();
		cpu_mask = gic_get_cpumask(gic);
		gic_cpu_map[cpu] = cpu_mask;

		/*
                 * Clear our mask from the other map entries in case they're
                 * still undefined.
                 */
		for (i = 0; i < NR_GIC_CPU_IF; i++)
			if (i != cpu)
				gic_cpu_map[i] &= ~cpu_mask;
	}

	gic_cpu_config(dist_base, NULL);

	writel_relaxed(GICC_INT_PRI_THRESHOLD, base + GIC_CPU_PRIMASK);
	gic_cpu_if_up(gic);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 53 38.13% 1 6.67%
russell king russell king 42 30.22% 5 33.33%
jon hunter jon hunter 30 21.58% 3 20.00%
marc zyngier marc zyngier 11 7.91% 3 20.00%
feng kan feng kan 2 1.44% 2 13.33%
santosh shilimkar santosh shilimkar 1 0.72% 1 6.67%
Total 139 100.00% 15 100.00%



int gic_cpu_if_down(unsigned int gic_nr)
{
	void __iomem *cpu_base;
	u32 val = 0;

	if (gic_nr >= CONFIG_ARM_GIC_MAX_NR)
		return -EINVAL;

	cpu_base = gic_data_cpu_base(&gic_data[gic_nr]);
	val = readl(cpu_base + GIC_CPU_CTRL);
	val &= ~GICC_ENABLE;
	writel_relaxed(val, cpu_base + GIC_CPU_CTRL);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 25 37.88% 1 25.00%
jon hunter jon hunter 25 37.88% 1 25.00%
feng kan feng kan 15 22.73% 1 25.00%
linus walleij linus walleij 1 1.52% 1 25.00%
Total 66 100.00% 4 100.00%

#ifdef CONFIG_CPU_PM
/*
 * Saves the GIC distributor registers during suspend or idle.  Must be called
 * with interrupts disabled but before powering down the GIC.  After calling
 * this function, no interrupts will be delivered by the GIC, and another
 * platform-specific wakeup source must be enabled.
 */


static void gic_dist_save(struct gic_chip_data *gic)
{
	unsigned int gic_irqs;
	void __iomem *dist_base;
	int i;

	if (WARN_ON(!gic))
		return;

	gic_irqs = gic->gic_irqs;
	dist_base = gic_data_dist_base(gic);

	if (!dist_base)
		return;

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)
		gic->saved_spi_conf[i] =
			readl_relaxed(dist_base + GIC_DIST_CONFIG + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
		gic->saved_spi_target[i] =
			readl_relaxed(dist_base + GIC_DIST_TARGET + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)
		gic->saved_spi_enable[i] =
			readl_relaxed(dist_base + GIC_DIST_ENABLE_SET + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)
		gic->saved_spi_active[i] =
			readl_relaxed(dist_base + GIC_DIST_ACTIVE_SET + i * 4);
}

Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 110 56.41% 1 12.50%
marc zyngier marc zyngier 37 18.97% 2 25.00%
russell king russell king 24 12.31% 3 37.50%
jon hunter jon hunter 22 11.28% 1 12.50%
linus walleij linus walleij 2 1.03% 1 12.50%
Total 195 100.00% 8 100.00%

/*
 * Restores the GIC distributor registers during resume or when coming out of
 * idle.  Must be called before enabling interrupts.  If a level interrupt
 * that occured while the GIC was suspended is still present, it will be
 * handled normally, but any edge interrupts that occured will not be seen by
 * the GIC and need to be handled by the platform-specific wakeup source.
 */


static void gic_dist_restore(struct gic_chip_data *gic)
{
	unsigned int gic_irqs;
	unsigned int i;
	void __iomem *dist_base;

	if (WARN_ON(!gic))
		return;

	gic_irqs = gic->gic_irqs;
	dist_base = gic_data_dist_base(gic);

	if (!dist_base)
		return;

	writel_relaxed(GICD_DISABLE, dist_base + GIC_DIST_CTRL);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)
		writel_relaxed(gic->saved_spi_conf[i],
			dist_base + GIC_DIST_CONFIG + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
		writel_relaxed(GICD_INT_DEF_PRI_X4,
			dist_base + GIC_DIST_PRI + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)
		writel_relaxed(gic->saved_spi_target[i],
			dist_base + GIC_DIST_TARGET + i * 4);

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {
		writel_relaxed(GICD_INT_EN_CLR_X32,
			dist_base + GIC_DIST_ENABLE_CLEAR + i * 4);
		writel_relaxed(gic->saved_spi_enable[i],
			dist_base + GIC_DIST_ENABLE_SET + i * 4);
	}

	for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {
		writel_relaxed(GICD_INT_EN_CLR_X32,
			dist_base + GIC_DIST_ACTIVE_CLEAR + i * 4);
		writel_relaxed(gic->saved_spi_active[i],
			dist_base + GIC_DIST_ACTIVE_SET + i * 4);
	}

	writel_relaxed(GICD_ENABLE, dist_base + GIC_DIST_CTRL);
}

Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 175 63.64% 1 11.11%
marc zyngier marc zyngier 67 24.36% 3 33.33%
jon hunter jon hunter 22 8.00% 1 11.11%
russell king russell king 6 2.18% 2 22.22%
feng kan feng kan 3 1.09% 1 11.11%
linus walleij linus walleij 2 0.73% 1 11.11%
Total 275 100.00% 9 100.00%



static void gic_cpu_save(struct gic_chip_data *gic)
{
	int i;
	u32 *ptr;
	void __iomem *dist_base;
	void __iomem *cpu_base;

	if (WARN_ON(!gic))
		return;

	dist_base = gic_data_dist_base(gic);
	cpu_base = gic_data_cpu_base(gic);

	if (!dist_base || !cpu_base)
		return;

	ptr = raw_cpu_ptr(gic->saved_ppi_enable);
	for (i = 0; i < DIV_ROUND_UP(32, 32); i++)
		ptr[i] = readl_relaxed(dist_base + GIC_DIST_ENABLE_SET + i * 4);

	ptr = raw_cpu_ptr(gic->saved_ppi_active);
	for (i = 0; i < DIV_ROUND_UP(32, 32); i++)
		ptr[i] = readl_relaxed(dist_base + GIC_DIST_ACTIVE_SET + i * 4);

	ptr = raw_cpu_ptr(gic->saved_ppi_conf);
	for (i = 0; i < DIV_ROUND_UP(32, 16); i++)
		ptr[i] = readl_relaxed(dist_base + GIC_DIST_CONFIG + i * 4);

}

Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 119 62.96% 1 16.67%
marc zyngier marc zyngier 47 24.87% 2 33.33%
jon hunter jon hunter 19 10.05% 1 16.67%
christoph lameter christoph lameter 2 1.06% 1 16.67%
linus walleij linus walleij 2 1.06% 1 16.67%
Total 189 100.00% 6 100.00%



static void gic_cpu_restore(struct gic_chip_data *gic)
{
	int i;
	u32 *ptr;
	void __iomem *dist_base;
	void __iomem *cpu_base;

	if (WARN_ON(!gic))
		return;

	dist_base = gic_data_dist_base(gic);
	cpu_base = gic_data_cpu_base(gic);

	if (!dist_base || !cpu_base)
		return;

	ptr = raw_cpu_ptr(gic->saved_ppi_enable);
	for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {
		writel_relaxed(GICD_INT_EN_CLR_X32,
			       dist_base + GIC_DIST_ENABLE_CLEAR + i * 4);
		writel_relaxed(ptr[i], dist_base + GIC_DIST_ENABLE_SET + i * 4);
	}

	ptr = raw_cpu_ptr(gic->saved_ppi_active);
	for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {
		writel_relaxed(GICD_INT_EN_CLR_X32,
			       dist_base + GIC_DIST_ACTIVE_CLEAR + i * 4);
		writel_relaxed(ptr[i], dist_base + GIC_DIST_ACTIVE_SET + i * 4);
	}

	ptr = raw_cpu_ptr(gic->saved_ppi_conf);
	for (i = 0; i < DIV_ROUND_UP(32, 16); i++)
		writel_relaxed(ptr[i], dist_base + GIC_DIST_CONFIG + i * 4);

	for (i = 0; i < DIV_ROUND_UP(32, 4); i++)
		writel_relaxed(GICD_INT_DEF_PRI_X4,
					dist_base + GIC_DIST_PRI + i * 4);

	writel_relaxed(GICC_INT_PRI_THRESHOLD, cpu_base + GIC_CPU_PRIMASK);
	gic_cpu_if_up(gic);
}

Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 158 59.85% 1 10.00%
marc zyngier marc zyngier 77 29.17% 3 30.00%
jon hunter jon hunter 22 8.33% 2 20.00%
feng kan feng kan 3 1.14% 2 20.00%
christoph lameter christoph lameter 2 0.76% 1 10.00%
linus walleij linus walleij 2 0.76% 1 10.00%
Total 264 100.00% 10 100.00%



static int gic_notifier(struct notifier_block *self, unsigned long cmd,	void *v)
{
	int i;

	for (i = 0; i < CONFIG_ARM_GIC_MAX_NR; i++) {
#ifdef CONFIG_GIC_NON_BANKED
		/* Skip over unused GICs */
		if (!gic_data[i].get_base)
			continue;
#endif
		switch (cmd) {
		case CPU_PM_ENTER:
			gic_cpu_save(&gic_data[i]);
			break;
		case CPU_PM_ENTER_FAILED:
		case CPU_PM_EXIT:
			gic_cpu_restore(&gic_data[i]);
			break;
		case CPU_CLUSTER_PM_ENTER:
			gic_dist_save(&gic_data[i]);
			break;
		case CPU_CLUSTER_PM_ENTER_FAILED:
		case CPU_CLUSTER_PM_EXIT:
			gic_dist_restore(&gic_data[i]);
			break;
		}
	}

	return NOTIFY_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 85 70.25% 1 20.00%
marc zyngier marc zyngier 17 14.05% 1 20.00%
jon hunter jon hunter 16 13.22% 1 20.00%
russell king russell king 2 1.65% 1 20.00%
linus walleij linus walleij 1 0.83% 1 20.00%
Total 121 100.00% 5 100.00%


static struct notifier_block gic_notifier_block = {
	.notifier_call = gic_notifier,
};



static int __init gic_pm_init(struct gic_chip_data *gic)
{
	gic->saved_ppi_enable = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,
		sizeof(u32));
	if (WARN_ON(!gic->saved_ppi_enable))
		return -ENOMEM;

	gic->saved_ppi_active = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,
		sizeof(u32));
	if (WARN_ON(!gic->saved_ppi_active))
		goto free_ppi_enable;

	gic->saved_ppi_conf = __alloc_percpu(DIV_ROUND_UP(32, 16) * 4,
		sizeof(u32));
	if (WARN_ON(!gic->saved_ppi_conf))
		goto free_ppi_active;

	if (gic == &gic_data[0])
		cpu_pm_register_notifier(&gic_notifier_block);

	return 0;

free_ppi_active:
	free_percpu(gic->saved_ppi_active);
free_ppi_enable:
	free_percpu(gic->saved_ppi_enable);

	return -ENOMEM;
}
Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 69 44.23% 1 20.00%
jon hunter jon hunter 48 30.77% 1 20.00%
marc zyngier marc zyngier 37 23.72% 2 40.00%
russell king russell king 2 1.28% 1 20.00%
Total 156 100.00% 5 100.00%

#else


static int __init gic_pm_init(struct gic_chip_data *gic)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
colin cross colin cross 9 60.00% 1 50.00%
jon hunter jon hunter 6 40.00% 1 50.00%
Total 15 100.00% 2 100.00%

#endif

#ifdef CONFIG_SMP


static void gic_raise_softirq(const struct cpumask *mask, unsigned int irq)
{
	int cpu;
	unsigned long flags, map = 0;

	raw_spin_lock_irqsave(&irq_controller_lock, flags);

	/* Convert our logical CPU mask into a physical one. */
	for_each_cpu(cpu, mask)
		map |= gic_cpu_map[cpu];

	/*
         * Ensure that stores to Normal memory are visible to the
         * other CPUs before they observe us issuing the IPI.
         */
	dmb(ishst);

	/* this always happens on GIC0 */
	writel_relaxed(map << 16 | irq, gic_data_dist_base(&gic_data[0]) + GIC_DIST_SOFTINT);

	raw_spin_unlock_irqrestore(&irq_controller_lock, flags);
}
Contributors
Person Tokens Prop Commits CommitProp
rob herring rob herring 56 66.67% 1 20.00%
nicolas pitre nicolas pitre 19 22.62% 1 20.00%
will deacon will deacon 5 5.95% 1 20.00%
javi merino javi merino 3 3.57% 1 20.00%
stephen boyd stephen boyd 1 1.19% 1 20.00%
Total 84 100.00% 5 100.00%

#endif

#ifdef CONFIG_BL_SWITCHER
/*
 * gic_send_sgi - send a SGI directly to given CPU interface number
 *
 * cpu_id: the ID for the destination CPU interface
 * irq: the IPI number to send a SGI for
 */


void gic_send_sgi(unsigned int cpu_id, unsigned int irq)
{
	BUG_ON(cpu_id >= NR_GIC_CPU_IF);
	cpu_id = 1 << cpu_id;
	/* this always happens on GIC0 */
	writel_relaxed((cpu_id << 16) | irq, gic_data_dist_base(&gic_data[0]) + GIC_DIST_SOFTINT);
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%

/*
 * gic_get_cpu_id - get the CPU interface ID for the specified CPU
 *
 * @cpu: the logical CPU number to get the GIC ID for.
 *
 * Return the CPU interface ID for the given logical CPU number,
 * or -1 if the CPU number is too large or the interface ID is
 * unknown (more than one bit set).
 */


int gic_get_cpu_id(unsigned int cpu)
{
	unsigned int cpu_bit;

	if (cpu >= NR_GIC_CPU_IF)
		return -1;
	cpu_bit = gic_cpu_map[cpu];
	if (cpu_bit & (cpu_bit - 1))
		return -1;
	return __ffs(cpu_bit);
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%

/*
 * gic_migrate_target - migrate IRQs to another CPU interface
 *
 * @new_cpu_id: the CPU target ID to migrate IRQs to
 *
 * Migrate all peripheral interrupts with a target matching the current CPU
 * to the interface corresponding to @new_cpu_id.  The CPU interface mapping
 * is also updated.  Targets to other CPU interfaces are unchanged.
 * This must be called with IRQs locally disabled.
 */


void gic_migrate_target(unsigned int new_cpu_id)
{
	unsigned int cur_cpu_id, gic_irqs, gic_nr = 0;
	void __iomem *dist_base;
	int i, ror_val, cpu = smp_processor_id();
	u32 val, cur_target_mask, active_mask;

	BUG_ON(gic_nr >= CONFIG_ARM_GIC_MAX_NR);

	dist_base = gic_data_dist_base(&gic_data[gic_nr]);
	if (!dist_base)
		return;
	gic_irqs = gic_data[gic_nr].gic_irqs;

	cur_cpu_id = __ffs(gic_cpu_map[cpu]);
	cur_target_mask = 0x01010101 << cur_cpu_id;
	ror_val = (cur_cpu_id - new_cpu_id) & 31;

	raw_spin_lock(&irq_controller_lock);

	/* Update the target interface for this logical CPU */
	gic_cpu_map[cpu] = 1 << new_cpu_id;

	/*
         * Find all the peripheral interrupts targetting the current
         * CPU interface and migrate them to the new CPU interface.
         * We skip DIST_TARGET 0 to 7 as they are read-only.
         */
	for (i = 8; i < DIV_ROUND_UP(gic_irqs, 4); i++) {
		val = readl_relaxed(dist_base + GIC_DIST_TARGET + i * 4);
		active_mask = val & cur_target_mask;
		if (active_mask) {
			val &= ~active_mask;
			val |= ror32(active_mask, ror_val);
			writel_relaxed(val, dist_base + GIC_DIST_TARGET + i*4);
		}
	}

	raw_spin_unlock(&irq_controller_lock);

	/*
         * Now let's migrate and clear any potential SGIs that might be
         * pending for us (cur_cpu_id).  Since GIC_DIST_SGI_PENDING_SET
         * is a banked register, we can only forward the SGI using
         * GIC_DIST_SOFTINT.  The original SGI source is lost but Linux
         * doesn't use that information anyway.
         *
         * For the same reason we do not adjust SGI source information
         * for previously sent SGIs by us to other CPUs either.
         */
	for (i = 0; i < 16; i += 4) {
		int j;
		val = readl_relaxed(dist_base + GIC_DIST_SGI_PENDING_SET + i);
		if (!val)
			continue;
		writel_relaxed(val, dist_base + GIC_DIST_SGI_PENDING_CLEAR + i);
		for (j = i; j < i + 4; j++) {
			if (val & 0xff)
				writel_relaxed((1 << (new_cpu_id + 16)) | j,
						dist_base + GIC_DIST_SOFTINT);
			val >>= 8;
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 284 98.27% 1 33.33%
linus walleij linus walleij 4 1.38% 1 33.33%
rob herring rob herring 1 0.35% 1 33.33%
Total 289 100.00% 3 100.00%

/*
 * gic_get_sgir_physaddr - get the physical address for the SGI register
 *
 * REturn the physical address of the SGI register to be used
 * by some early assembly code when the kernel is not yet available.
 */

static unsigned long gic_dist_physaddr;



unsigned long gic_get_sgir_physaddr(void)
{
	if (!gic_dist_physaddr)
		return 0;
	return gic_dist_physaddr + GIC_DIST_SOFTINT;
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



void __init gic_init_physaddr(struct device_node *node)
{
	struct resource res;
	if (of_address_to_resource(node, 0, &res) == 0) {
		gic_dist_physaddr = res.start;
		pr_info("GIC physical location is %#lx\n", gic_dist_physaddr);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas pitre nicolas pitre 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%

#else

#define gic_init_physaddr(node)  do { } while (0)
#endif



static int gic_irq_domain_map(struct irq_domain *d, unsigned int irq,
				irq_hw_number_t hw)
{
	struct gic_chip_data *gic = d->host_data;

	if (hw < 32) {
		irq_set_percpu_devid(irq);
		irq_domain_set_info(d, irq, hw, &gic->chip, d->host_data,
				    handle_percpu_devid_irq, NULL, NULL);
		irq_set_status_flags(irq, IRQ_NOAUTOEN);
	} else {
		irq_domain_set_info(d, irq, hw, &gic->chip, d->host_data,
				    handle_fasteoi_irq, NULL, NULL);
		irq_set_probe(irq);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 60 56.60% 1 20.00%
yingjoe chen yingjoe chen 26 24.53% 1 20.00%
linus walleij linus walleij 9 8.49% 1 20.00%
marc zyngier marc zyngier 8 7.55% 1 20.00%
rob herring rob herring 3 2.83% 1 20.00%
Total 106 100.00% 5 100.00%



static void gic_irq_domain_unmap(struct irq_domain *d, unsigned int irq)
{
}

Contributors
Person Tokens Prop Commits CommitProp
r sricharan r sricharan 13 92.86% 1 50.00%
marc zyngier marc zyngier 1 7.14% 1 50.00%
Total 14 100.00% 2 100.00%



static int gic_irq_domain_translate(struct irq_domain *d,
				    struct irq_fwspec *fwspec,
				    unsigned long *hwirq,
				    unsigned int *type)
{
	if (is_of_node(fwspec->fwnode)) {
		if (fwspec->param_count < 3)
			return -EINVAL;

		/* Get the interrupt number and add 16 to skip over SGIs */
		*hwirq = fwspec->param[1] + 16;

		/*
                 * For SPIs, we need to add 16 more to get the GIC irq
                 * ID number
                 */
		if (!fwspec->param[0])
			*hwirq += 16;

		*type = fwspec->param[2] & IRQ_TYPE_SENSE_MASK;
		return 0;
	}

	if (is_fwnode_irqchip(fwspec->fwnode)) {
		if(fwspec->param_count != 2)
			return -EINVAL;

		*hwirq = fwspec->param[0];
		*type = fwspec->param[1];
		return 0;
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 140 97.90% 2 66.67%
suravee suthikulpanit suravee suthikulpanit 3 2.10% 1 33.33%
Total 143 100.00% 3 100.00%

#ifdef CONFIG_SMP


static int gic_secondary_init(struct notifier_block *nfb, unsigned long action,
			      void *hcpu)
{
	if (action == CPU_STARTING || action == CPU_STARTING_FROZEN)
		gic_cpu_init(&gic_data[0]);
	return NOTIFY_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
catalin marinas catalin marinas 37 90.24% 1 50.00%
shawn guo shawn guo 4 9.76% 1 50.00%
Total 41 100.00% 2 100.00%

/*
 * Notifier for enabling the GIC CPU interface. Set an arbitrarily high
 * priority because the GIC needs to be up before the ARM generic timers.
 */

static struct notifier_block gic_cpu_notifier = {
	.notifier_call = gic_secondary_init,
	.priority = 100,
};
#endif



static int gic_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
				unsigned int nr_irqs, void *arg)
{
	int i, ret;
	irq_hw_number_t hwirq;
	unsigned int type = IRQ_TYPE_NONE;
	struct irq_fwspec *fwspec = arg;

	ret = gic_irq_domain_translate(domain, fwspec, &hwirq, &type);
	if (ret)
		return ret;

	for (i = 0; i < nr_irqs; i++)
		gic_irq_domain_map(domain, virq + i, hwirq + i);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
yingjoe chen yingjoe chen 91 95.79% 1 50.00%
marc zyngier marc zyngier 4 4.21% 1 50.00%
Total 95 100.00% 2 100.00%


static const struct irq_domain_ops gic_irq_domain_hierarchy_ops = {
	.translate = gic_irq_domain_translate,
	.alloc = gic_irq_domain_alloc,
	.free = irq_domain_free_irqs_top,
};


static const struct irq_domain_ops gic_irq_domain_ops = {
	.map = gic_irq_domain_map,
	.unmap = gic_irq_domain_unmap,
};



static int __init __gic_init_bases(struct gic_chip_data *gic, int irq_start,
				   struct fwnode_handle *handle)
{
	irq_hw_number_t hwirq_base;
	int gic_irqs, irq_base, i, ret;

	if (WARN_ON(!gic || gic->domain))
		return -EINVAL;

	/* Initialize irq_chip */
	gic->chip = gic_chip;

	if (static_key_true(&supports_deactivate) && gic == &gic_data[0]) {
		gic->chip.irq_mask = gic_eoimode1_mask_irq;
		gic->chip.irq_eoi = gic_eoimode1_eoi_irq;
		gic->chip.irq_set_vcpu_affinity = gic_irq_set_vcpu_affinity;
		gic->chip.name = kasprintf(GFP_KERNEL, "GICv2");
	} else {
		gic->chip.name = kasprintf(GFP_KERNEL, "GIC-%d",
					   (int)(gic - &gic_data[0]));
	}

#ifdef CONFIG_SMP
	if (gic == &gic_data[0])
		gic->chip.irq_set_affinity = gic_set_affinity;
#endif

	if (IS_ENABLED(CONFIG_GIC_NON_BANKED) && gic->percpu_offset) {
		/* Frankein-GIC without banked registers... */
		unsigned int cpu;

		gic->dist_base.percpu_base = alloc_percpu(void __iomem *);
		gic->cpu_base.percpu_base = alloc_percpu(void __iomem *);
		if (WARN_ON(!gic->dist_base.percpu_base ||
			    !gic->cpu_base.percpu_base)) {
			ret = -ENOMEM;
			goto error;
		}

		for_each_possible_cpu(cpu) {
			u32 mpidr = cpu_logical_map(cpu);
			u32 core_id = MPIDR_AFFINITY_LEVEL(mpidr, 0);
			unsigned long offset = gic->percpu_offset * core_id;
			*per_cpu_ptr(gic->dist_base.percpu_base, cpu) =
				gic->raw_dist_base + offset;
			*per_cpu_ptr(gic->cpu_base.percpu_base, cpu) =
				gic->raw_cpu_base + offset;
		}

		gic_set_base_accessor(gic, gic_get_percpu_base);
	} else {
		/* Normal, sane GIC... */
		WARN(gic->percpu_offset,
		     "GIC_NON_BANKED not enabled, ignoring %08x offset!",
		     gic->percpu_offset);
		gic->dist_base.common_base = gic->raw_dist_base;
		gic->cpu_base.common_base = gic->raw_cpu_base;
		gic_set_base_accessor(gic, gic_get_common_base);
	}

	/*
         * Find out how many interrupts are supported.
         * The GIC only supports up to 1020 interrupt sources.
         */
	gic_irqs = readl_relaxed(gic_data_dist_base(gic) + GIC_DIST_CTR) & 0x1f;
	gic_irqs = (gic_irqs + 1) * 32;
	if (gic_irqs > 1020)
		gic_irqs = 1020;
	gic->gic_irqs = gic_irqs;

	if (handle) {		/* DT/ACPI */
		gic->domain = irq_domain_create_linear(handle, gic_irqs,
						       &gic_irq_domain_hierarchy_ops,
						       gic);
	} else {		/* Legacy support */
		/*
                 * For primary GICs, skip over SGIs.
                 * For secondary GICs, skip over PPIs, too.
                 */
		if (gic == &gic_data[0] && (irq_start & 31) > 0) {
			hwirq_base = 16;
			if (irq_start != -1)
				irq_start = (irq_start & ~31) + 16;
		} else {
			hwirq_base = 32;
		}

		gic_irqs -= hwirq_base; /* calculate # of irqs to allocate */

		irq_base = irq_alloc_descs(irq_start, 16, gic_irqs,
					   numa_node_id());
		if (irq_base < 0) {
			WARN(1, "Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
			     irq_start);
			irq_base = irq_start;
		}

		gic->domain = irq_domain_add_legacy(NULL, gic_irqs, irq_base,
					hwirq_base, &gic_irq_domain_ops, gic);
	}

	if (WARN_ON(!gic->domain)) {
		ret = -ENODEV;
		goto error;
	}

	if (gic == &gic_data[0]) {
		/*
                 * Initialize the CPU interface map to all CPUs.
                 * It will be refined as each CPU probes its ID.
                 * This is only necessary for the primary GIC.
                 */
		for (i = 0; i < NR_GIC_CPU_IF; i++)
			gic_cpu_map[i] = 0xff;
#ifdef CONFIG_SMP
		set_smp_cross_call(gic_raise_softirq);
		register_cpu_notifier(&gic_cpu_notifier);
#endif
		set_handle_irq(gic_handle_irq);
		if (static_key_true(&supports_deactivate))
			pr_info("GIC: Using split EOI/Deactivate mode\n");
	}

	gic_dist_init(gic);
	ret = gic_cpu_init(gic);
	if (ret)
		goto error;

	ret = gic_pm_init(gic);
	if (ret)
		goto error;

	return 0;

error:
	if (IS_ENABLED(CONFIG_GIC_NON_BANKED) && gic->percpu_offset) {
		free_percpu(gic->dist_base.percpu_base);
		free_percpu(gic->cpu_base.percpu_base);
	}

	kfree(gic->chip.name);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jon hunter jon hunter 222 31.81% 5 17.24%
marc zyngier marc zyngier 160 22.92% 5 17.24%
rob herring rob herring 91 13.04% 4 13.79%
yingjoe chen yingjoe chen 67 9.60% 1 3.45%
linus walleij linus walleij 47 6.73% 1 3.45%
colin cross colin cross 33 4.73% 1 3.45%
grant likely grant likely 28 4.01% 1 3.45%
tomasz figa tomasz figa 19 2.72% 1 3.45%
russell king russell king 9 1.29% 3 10.34%
mark rutland mark rutland 7 1.00% 1 3.45%
catalin marinas catalin marinas 6 0.86% 1 3.45%
r sricharan r sricharan 3 0.43% 1 3.45%
nicolas pitre nicolas pitre 2 0.29% 1 3.45%
arnd bergmann arnd bergmann 2 0.29% 1 3.45%
thomas gleixner thomas gleixner 1 0.14% 1 3.45%
lennert buytenhek lennert buytenhek 1 0.14% 1 3.45%
Total 698 100.00% 29 100.00%



void __init gic_init(unsigned int gic_nr, int irq_start,
		     void __iomem *dist_base, void __iomem *cpu_base)
{
	struct gic_chip_data *gic;

	if (WARN_ON(gic_nr >= CONFIG_ARM_GIC_MAX_NR))
		return;

	/*
         * Non-DT/ACPI systems won't run a hypervisor, so let's not
         * bother with these...
         */
	static_key_slow_dec(&supports_deactivate);

	gic = &gic_data[gic_nr];
	gic->raw_dist_base = dist_base;
	gic->raw_cpu_base = cpu_base;

	__gic_init_bases(gic, irq_start, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 38 51.35% 2 66.67%
jon hunter jon hunter 36 48.65% 1 33.33%
Total 74 100.00% 3 100.00%



static void gic_teardown(struct gic_chip_data *gic)
{
	if (WARN_ON(!gic))
		return;

	if (gic->raw_dist_base)
		iounmap(gic->raw_dist_base);
	if (gic->raw_cpu_base)
		iounmap(gic->raw_cpu_base);
}

Contributors
Person Tokens Prop Commits CommitProp
jon hunter jon hunter 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%

#ifdef CONFIG_OF

static int gic_cnt __initdata;



static bool gic_check_eoimode(struct device_node *node, void __iomem **base)
{
	struct resource cpuif_res;

	of_address_to_resource(node, 1, &cpuif_res);

	if (!is_hyp_mode_available())
		return false;
	if (resource_size(&cpuif_res) < SZ_8K)
		return false;
	if (resource_size(&cpuif_res) == SZ_128K) {
		u32 val_low, val_high;

		/*
                 * Verify that we have the first 4kB of a GIC400
                 * aliased over the first 64kB by checking the
                 * GICC_IIDR register on both ends.
                 */
		val_low = readl_relaxed(*base + GIC_CPU_IDENT);
		val_high = readl_relaxed(*base + GIC_CPU_IDENT + 0xf000);
		if ((val_low & 0xffff0fff) != 0x0202043B ||
		    val_low != val_high)
			return false;

		/*
                 * Move the base up by 60kB, so that we have a 8kB
                 * contiguous region, which allows us to use GICC_DIR
                 * at its normal offset. Please pass me that bucket.
                 */
		*base += 0xf000;
		cpuif_res.start += 0xf000;
		pr_warn("GIC: Adjusting CPU interface base to %pa",
			&cpuif_res.start);
	}

	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 135 100.00% 1 100.00%
Total 135 100.00% 1 100.00%



static int __init gic_of_setup(struct gic_chip_data *gic, struct device_node *node)
{
	if (!gic || !node)
		return -EINVAL;

	gic->raw_dist_base = of_iomap(node, 0);
	if (WARN(!gic->raw_dist_base, "unable to map gic dist registers\n"))
		goto error;

	gic->raw_cpu_base = of_iomap(node, 1);
	if (WARN(!gic->raw_cpu_base, "unable to map gic cpu registers\n"))
		goto error;

	if (of_property_read_u32(node, "cpu-offset", &gic->percpu_offset))
		gic->percpu_offset = 0;

	return 0;

error:
	gic_teardown(gic);

	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
jon hunter jon hunter 67 58.26% 3 60.00%
rob herring rob herring 47 40.87% 1 20.00%
linus torvalds linus torvalds 1 0.87% 1 20.00%
Total 115 100.00% 5 100.00%



static void __init gic_of_setup_kvm_info(struct device_node *node)
{
	int ret;
	struct resource *vctrl_res = &gic_v2_kvm_info.vctrl;
	struct resource *vcpu_res = &gic_v2_kvm_info.vcpu;

	gic_v2_kvm_info.type = GIC_V2;

	gic_v2_kvm_info.maint_irq = irq_of_parse_and_map(node, 0);
	if (!gic_v2_kvm_info.maint_irq)
		return;

	ret = of_address_to_resource(node, 2, vctrl_res);
	if (ret)
		return;

	ret = of_address_to_resource(node, 3, vcpu_res);
	if (ret)
		return;

	gic_set_kvm_info(&gic_v2_kvm_info);
}

Contributors
Person Tokens Prop Commits CommitProp
julien grall julien grall 98 100.00% 1 100.00%
Total 98 100.00% 1 100.00%


int __init

gic_of_init(struct device_node *node, struct device_node *parent)
{
	struct gic_chip_data *gic;
	int irq, ret;

	if (WARN_ON(!node))
		return -ENODEV;

	if (WARN_ON(gic_cnt >= CONFIG_ARM_GIC_MAX_NR))
		return -EINVAL;

	gic = &gic_data[gic_cnt];

	ret = gic_of_setup(gic, node);
	if (ret)
		return ret;

	/*
         * Disable split EOI/Deactivate if either HYP is not available
         * or the CPU interface is too small.
         */
	if (gic_cnt == 0 && !gic_check_eoimode(node, &gic->raw_cpu_base))
		static_key_slow_dec(&supports_deactivate);

	ret = __gic_init_bases(gic, -1, &node->fwnode);
	if (ret) {
		gic_teardown(gic);
		return ret;
	}

	if (!gic_cnt) {
		gic_init_physaddr(node);
		gic_of_setup_kvm_info(node);
	}

	if (parent) {
		irq = irq_of_parse_and_map(node, 0);
		gic_cascade_irq(gic_cnt, irq);
	}

	if (IS_ENABLED(CONFIG_ARM_GIC_V2M))
		gicv2m_init(&node->fwnode, gic_data[gic_cnt].domain);

	gic_cnt++;
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
jon hunter jon hunter 92 47.18% 3 20.00%
rob herring rob herring 37 18.97% 2 13.33%
marc zyngier marc zyngier 26 13.33% 5 33.33%
suravee suthikulpanit suravee suthikulpanit 22 11.28% 2 13.33%
nicolas pitre nicolas pitre 10 5.13% 1 6.67%
julien grall julien grall 7 3.59% 1 6.67%
grant likely grant likely 1 0.51% 1 6.67%
Total 195 100.00% 15 100.00%

IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
IRQCHIP_DECLARE(arm11mp_gic, "arm,arm11mp-gic", gic_of_init);
IRQCHIP_DECLARE(arm1176jzf_dc_gic, "arm,arm1176jzf-devchip-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init);
IRQCHIP_DECLARE(msm_8660_qgic, "qcom,msm-8660-qgic", gic_of_init);
IRQCHIP_DECLARE(msm_qgic2, "qcom,msm-qgic2", gic_of_init);
IRQCHIP_DECLARE(pl390, "arm,pl390", gic_of_init);

#endif

#ifdef CONFIG_ACPI
static struct
{
	
phys_addr_t cpu_phys_base;
	
u32 maint_irq;
	
int maint_irq_mode;
	
phys_addr_t vctrl_base;
	
phys_addr_t vcpu_base;
} 
acpi_data __initdata;


static int __init

gic_acpi_parse_madt_cpu(struct acpi_subtable_header *header,
			const unsigned long end)
{
	struct acpi_madt_generic_interrupt *processor;
	phys_addr_t gic_cpu_base;
	static int cpu_base_assigned;

	processor = (struct acpi_madt_generic_interrupt *)header;

	if (BAD_MADT_GICC_ENTRY(processor, end))
		return -EINVAL;

	/*
         * There is no support for non-banked GICv1/2 register in ACPI spec.
         * All CPU interface addresses have to be the same.
         */
	gic_cpu_base = processor->base_address;
	if (cpu_base_assigned && gic_cpu_base != acpi_data.cpu_phys_base)
		return -EINVAL;

	acpi_data.cpu_phys_base = gic_cpu_base;
	acpi_data.maint_irq = processor->vgic_interrupt;
	acpi_data.maint_irq_mode = (processor->flags & ACPI_MADT_VGIC_IRQ_MODE) ?
				    ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE;
	acpi_data.vctrl_base = processor->gich_base_address;
	acpi_data.vcpu_base = processor->gicv_base_address;

	cpu_base_assigned = 1;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
tomasz nowicki tomasz nowicki 78 62.40% 1 25.00%
julien grall julien grall 46 36.80% 2 50.00%
al stone al stone 1 0.80% 1 25.00%
Total 125 100.00% 4 100.00%

/* The things you have to do to just *count* something... */


static int __init acpi_dummy_func(struct acpi_subtable_header *header,
				  const unsigned long end)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
tomasz nowicki tomasz nowicki 15 75.00% 1 50.00%
marc zyngier marc zyngier 5 25.00% 1 50.00%
Total 20 100.00% 2 100.00%



static bool __init acpi_gic_redist_is_present(void)
{
	return acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR,
				     acpi_dummy_func, 0) > 0;
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static bool __init gic_validate_dist(struct acpi_subtable_header *header,
				     struct acpi_probe_entry *ape)
{
	struct acpi_madt_generic_distributor *dist;
	dist = (struct acpi_madt_generic_distributor *)header;

	return (dist->version == ape->driver_data &&
		(dist->version != ACPI_MADT_GIC_VERSION_NONE ||
		 !acpi_gic_redist_is_present()));
}

Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 35 64.81% 1 50.00%
tomasz nowicki tomasz nowicki 19 35.19% 1 50.00%
Total 54 100.00% 2 100.00%


#define ACPI_GICV2_DIST_MEM_SIZE	(SZ_4K)

#define ACPI_GIC_CPU_IF_MEM_SIZE	(SZ_8K)

#define ACPI_GICV2_VCTRL_MEM_SIZE	(SZ_4K)

#define ACPI_GICV2_VCPU_MEM_SIZE	(SZ_8K)



static void __init gic_acpi_setup_kvm_info(void)
{
	int irq;
	struct resource *vctrl_res = &gic_v2_kvm_info.vctrl;
	struct resource *vcpu_res = &gic_v2_kvm_info.vcpu;

	gic_v2_kvm_info.type = GIC_V2;

	if (!acpi_data.vctrl_base)
		return;

	vctrl_res->flags = IORESOURCE_MEM;
	vctrl_res->start = acpi_data.vctrl_base;
	vctrl_res->end = vctrl_res->start + ACPI_GICV2_VCTRL_MEM_SIZE - 1;

	if (!acpi_data.vcpu_base)
		return;

	vcpu_res->flags = IORESOURCE_MEM;
	vcpu_res->start = acpi_data.vcpu_base;
	vcpu_res->end = vcpu_res->start + ACPI_GICV2_VCPU_MEM_SIZE - 1;

	irq = acpi_register_gsi(NULL, acpi_data.maint_irq,
				acpi_data.maint_irq_mode,
				ACPI_ACTIVE_HIGH);
	if (irq <= 0)
		return;

	gic_v2_kvm_info.maint_irq = irq;

	gic_set_kvm_info(&gic_v2_kvm_info);
}

Contributors
Person Tokens Prop Commits CommitProp
julien grall julien grall 142 100.00% 1 100.00%
Total 142 100.00% 1 100.00%



static int __init gic_v2_acpi_init(struct acpi_subtable_header *header,
				   const unsigned long end)
{
	struct acpi_madt_generic_distributor *dist;
	struct fwnode_handle *domain_handle;
	struct gic_chip_data *gic = &gic_data[0];
	int count, ret;

	/* Collect CPU base addresses */
	count = acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
				      gic_acpi_parse_madt_cpu, 0);
	if (count <= 0) {
		pr_err("No valid GICC entries exist\n");
		return -EINVAL;
	}

	gic->raw_cpu_base = ioremap(acpi_data.cpu_phys_base, ACPI_GIC_CPU_IF_MEM_SIZE);
	if (!gic->raw_cpu_base) {
		pr_err("Unable to map GICC registers\n");
		return -ENOMEM;
	}

	dist = (struct acpi_madt_generic_distributor *)header;
	gic->raw_dist_base = ioremap(dist->base_address,
				     ACPI_GICV2_DIST_MEM_SIZE);
	if (!gic->raw_dist_base) {
		pr_err("Unable to map GICD registers\n");
		gic_teardown(gic);
		return -ENOMEM;
	}

	/*
         * Disable split EOI/Deactivate if HYP is not available. ACPI
         * guarantees that we'll always have a GICv2, so the CPU
         * interface will always be the right size.
         */
	if (!is_hyp_mode_available())
		static_key_slow_dec(&supports_deactivate);

	/*
         * Initialize GIC instance zero (no multi-GIC support).
         */
	domain_handle = irq_domain_alloc_fwnode(gic->raw_dist_base);
	if (!domain_handle) {
		pr_err("Unable to allocate domain handle\n");
		gic_teardown(gic);
		return -ENOMEM;
	}

	ret = __gic_init_bases(gic, -1, domain_handle);
	if (ret) {
		pr_err("Failed to initialise GIC\n");
		irq_domain_free_fwnode(domain_handle);
		gic_teardown(gic);
		return ret;
	}

	acpi_set_irq_model(ACPI_IRQ_MODEL_GIC, domain_handle);

	if (IS_ENABLED(CONFIG_ARM_GIC_V2M))
		gicv2m_init(NULL, gic_data[0].domain);

	gic_acpi_setup_kvm_info();

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
tomasz nowicki tomasz nowicki 97 37.31% 1 8.33%
marc zyngier marc zyngier 77 29.62% 4 33.33%
jon hunter jon hunter 59 22.69% 3 25.00%
suravee suthikulpanit suravee suthikulpanit 19 7.31% 1 8.33%
julien grall julien grall 6 2.31% 2 16.67%
lorenzo pieralisi lorenzo pieralisi 2 0.77% 1 8.33%
Total 260 100.00% 12 100.00%

IRQCHIP_ACPI_DECLARE(gic_v2, ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR,
		     gic_validate_dist, ACPI_MADT_GIC_VERSION_V2,
		     gic_v2_acpi_init);
IRQCHIP_ACPI_DECLARE(gic_v2_maybe, ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR,
		     gic_validate_dist, ACPI_MADT_GIC_VERSION_NONE,
		     gic_v2_acpi_init);
#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
marc zyngier marc zyngier 1868 28.79% 24 18.90%
colin cross colin cross 782 12.05% 1 0.79%
jon hunter jon hunter 758 11.68% 10 7.87%
nicolas pitre nicolas pitre 608 9.37% 6 4.72%
russell king russell king 442 6.81% 12 9.45%
julien grall julien grall 331 5.10% 2 1.57%
rob herring rob herring 330 5.09% 9 7.09%
catalin marinas catalin marinas 257 3.96% 6 4.72%
tomasz nowicki tomasz nowicki 220 3.39% 1 0.79%
yingjoe chen yingjoe chen 205 3.16% 1 0.79%
grant likely grant likely 98 1.51% 2 1.57%
linus walleij linus walleij 97 1.49% 3 2.36%
feng kan feng kan 73 1.12% 2 1.57%
rabin vincent rabin vincent 62 0.96% 1 0.79%
thomas gleixner thomas gleixner 59 0.91% 6 4.72%
suravee suthikulpanit suravee suthikulpanit 53 0.82% 4 3.15%
lennert buytenhek lennert buytenhek 52 0.80% 1 0.79%
will deacon will deacon 51 0.79% 5 3.94%
tomasz figa tomasz figa 22 0.34% 1 0.79%
r sricharan r sricharan 19 0.29% 1 0.79%
santosh shilimkar santosh shilimkar 12 0.18% 2 1.57%
matthias brugger matthias brugger 9 0.14% 1 0.79%
sudeep holla sudeep holla 9 0.14% 2 1.57%
geert uytterhoeven geert uytterhoeven 9 0.14% 1 0.79%
stephen boyd stephen boyd 8 0.12% 2 1.57%
mark rutland mark rutland 7 0.11% 1 0.79%
christoph lameter christoph lameter 6 0.09% 2 1.57%
liviu dudau liviu dudau 5 0.08% 1 0.79%
jiang liu jiang liu 4 0.06% 1 0.79%
shawn guo shawn guo 4 0.06% 1 0.79%
rusty russell rusty russell 4 0.06% 1 0.79%
joel porquet joel porquet 3 0.05% 1 0.79%
yinghai lu yinghai lu 3 0.05% 1 0.79%
chao xie chao xie 3 0.05% 1 0.79%
arnd bergmann arnd bergmann 3 0.05% 2 1.57%
javi merino javi merino 3 0.05% 1 0.79%
pawel moll pawel moll 2 0.03% 1 0.79%
lorenzo pieralisi lorenzo pieralisi 2 0.03% 1 0.79%
david brownell david brownell 1 0.02% 1 0.79%
abhijeet dharmapurikar abhijeet dharmapurikar 1 0.02% 1 0.79%
linus torvalds linus torvalds 1 0.02% 1 0.79%
haojian zhuang haojian zhuang 1 0.02% 1 0.79%
sergei shtylyov sergei shtylyov 1 0.02% 1 0.79%
al stone al stone 1 0.02% 1 0.79%
Total 6489 100.00% 127 100.00%
  Directory: drivers/irqchip

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
marc zyngier	marc zyngier	20	100.00%	2	100.00%
	Total	20	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/irqchip/irq-gic.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
