irq-mips-gic.c 17.7 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2008 Ralf Baechle (ralf@linux-mips.org)
 * Copyright (C) 2012 MIPS Technologies, Inc.  All rights reserved.
 */
9 10
#include <linux/bitmap.h>
#include <linux/init.h>
11
#include <linux/interrupt.h>
12
#include <linux/irqchip/mips-gic.h>
13
#include <linux/sched.h>
14
#include <linux/smp.h>
15
#include <linux/irq.h>
16
#include <linux/clocksource.h>
17 18

#include <asm/io.h>
S
Steven J. Hill 已提交
19 20
#include <asm/setup.h>
#include <asm/traps.h>
21 22 23
#include <linux/hardirq.h>
#include <asm-generic/bitops/find.h>

24
unsigned int gic_frequency;
25
unsigned int gic_present;
S
Steven J. Hill 已提交
26

27
struct gic_pcpu_mask {
28
	DECLARE_BITMAP(pcpu_mask, GIC_MAX_INTRS);
29 30 31
};

struct gic_pending_regs {
32
	DECLARE_BITMAP(pending, GIC_MAX_INTRS);
33 34 35
};

struct gic_intrmask_regs {
36
	DECLARE_BITMAP(intrmask, GIC_MAX_INTRS);
37 38
};

39
static void __iomem *gic_base;
40
static struct gic_pcpu_mask pcpu_masks[NR_CPUS];
41 42
static struct gic_pending_regs pending_regs[NR_CPUS];
static struct gic_intrmask_regs intrmask_regs[NR_CPUS];
43
static DEFINE_SPINLOCK(gic_lock);
44
static struct irq_domain *gic_irq_domain;
45
static int gic_shared_intrs;
46
static int gic_vpes;
47
static unsigned int gic_cpu_pin;
48
static struct irq_chip gic_level_irq_controller, gic_edge_irq_controller;
49

50 51
static void __gic_irq_dispatch(void);

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
static inline unsigned int gic_read(unsigned int reg)
{
	return __raw_readl(gic_base + reg);
}

static inline void gic_write(unsigned int reg, unsigned int val)
{
	__raw_writel(val, gic_base + reg);
}

static inline void gic_update_bits(unsigned int reg, unsigned int mask,
				   unsigned int val)
{
	unsigned int regval;

	regval = gic_read(reg);
	regval &= ~mask;
	regval |= val;
	gic_write(reg, regval);
}

static inline void gic_reset_mask(unsigned int intr)
{
	gic_write(GIC_REG(SHARED, GIC_SH_RMASK) + GIC_INTR_OFS(intr),
		  1 << GIC_INTR_BIT(intr));
}

static inline void gic_set_mask(unsigned int intr)
{
	gic_write(GIC_REG(SHARED, GIC_SH_SMASK) + GIC_INTR_OFS(intr),
		  1 << GIC_INTR_BIT(intr));
}

static inline void gic_set_polarity(unsigned int intr, unsigned int pol)
{
	gic_update_bits(GIC_REG(SHARED, GIC_SH_SET_POLARITY) +
			GIC_INTR_OFS(intr), 1 << GIC_INTR_BIT(intr),
			pol << GIC_INTR_BIT(intr));
}

static inline void gic_set_trigger(unsigned int intr, unsigned int trig)
{
	gic_update_bits(GIC_REG(SHARED, GIC_SH_SET_TRIGGER) +
			GIC_INTR_OFS(intr), 1 << GIC_INTR_BIT(intr),
			trig << GIC_INTR_BIT(intr));
}

static inline void gic_set_dual_edge(unsigned int intr, unsigned int dual)
{
	gic_update_bits(GIC_REG(SHARED, GIC_SH_SET_DUAL) + GIC_INTR_OFS(intr),
			1 << GIC_INTR_BIT(intr),
			dual << GIC_INTR_BIT(intr));
}

static inline void gic_map_to_pin(unsigned int intr, unsigned int pin)
{
	gic_write(GIC_REG(SHARED, GIC_SH_INTR_MAP_TO_PIN_BASE) +
		  GIC_SH_MAP_TO_PIN(intr), GIC_MAP_TO_PIN_MSK | pin);
}

static inline void gic_map_to_vpe(unsigned int intr, unsigned int vpe)
{
	gic_write(GIC_REG(SHARED, GIC_SH_INTR_MAP_TO_VPE_BASE) +
		  GIC_SH_MAP_TO_VPE_REG_OFF(intr, vpe),
		  GIC_SH_MAP_TO_VPE_REG_BIT(vpe));
}

119
#if defined(CONFIG_CSRC_GIC) || defined(CONFIG_CEVT_GIC)
120 121 122 123 124
cycle_t gic_read_count(void)
{
	unsigned int hi, hi2, lo;

	do {
125 126 127
		hi = gic_read(GIC_REG(SHARED, GIC_SH_COUNTER_63_32));
		lo = gic_read(GIC_REG(SHARED, GIC_SH_COUNTER_31_00));
		hi2 = gic_read(GIC_REG(SHARED, GIC_SH_COUNTER_63_32));
128 129 130 131
	} while (hi2 != hi);

	return (((cycle_t) hi) << 32) + lo;
}
132

133 134 135 136
unsigned int gic_get_count_width(void)
{
	unsigned int bits, config;

137
	config = gic_read(GIC_REG(SHARED, GIC_SH_CONFIG));
138 139 140 141 142 143
	bits = 32 + 4 * ((config & GIC_SH_CONFIG_COUNTBITS_MSK) >>
			 GIC_SH_CONFIG_COUNTBITS_SHF);

	return bits;
}

144 145
void gic_write_compare(cycle_t cnt)
{
146
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE_HI),
147
				(int)(cnt >> 32));
148
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE_LO),
149 150 151
				(int)(cnt & 0xffffffff));
}

152 153 154 155 156 157
void gic_write_cpu_compare(cycle_t cnt, int cpu)
{
	unsigned long flags;

	local_irq_save(flags);

158 159
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_OTHER_ADDR), cpu);
	gic_write(GIC_REG(VPE_OTHER, GIC_VPE_COMPARE_HI),
160
				(int)(cnt >> 32));
161
	gic_write(GIC_REG(VPE_OTHER, GIC_VPE_COMPARE_LO),
162 163 164 165 166
				(int)(cnt & 0xffffffff));

	local_irq_restore(flags);
}

167 168 169 170
cycle_t gic_read_compare(void)
{
	unsigned int hi, lo;

171 172
	hi = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE_HI));
	lo = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE_LO));
173 174 175

	return (((cycle_t) hi) << 32) + lo;
}
176 177
#endif

178 179 180 181 182 183 184 185
static bool gic_local_irq_is_routable(int intr)
{
	u32 vpe_ctl;

	/* All local interrupts are routable in EIC mode. */
	if (cpu_has_veic)
		return true;

186
	vpe_ctl = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_CTL));
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	switch (intr) {
	case GIC_LOCAL_INT_TIMER:
		return vpe_ctl & GIC_VPE_CTL_TIMER_RTBL_MSK;
	case GIC_LOCAL_INT_PERFCTR:
		return vpe_ctl & GIC_VPE_CTL_PERFCNT_RTBL_MSK;
	case GIC_LOCAL_INT_FDC:
		return vpe_ctl & GIC_VPE_CTL_FDC_RTBL_MSK;
	case GIC_LOCAL_INT_SWINT0:
	case GIC_LOCAL_INT_SWINT1:
		return vpe_ctl & GIC_VPE_CTL_SWINT_RTBL_MSK;
	default:
		return true;
	}
}

S
Steven J. Hill 已提交
202 203 204 205
unsigned int gic_get_timer_pending(void)
{
	unsigned int vpe_pending;

206
	vpe_pending = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_PEND));
R
Ralf Baechle 已提交
207
	return vpe_pending & GIC_VPE_PEND_TIMER_MSK;
S
Steven J. Hill 已提交
208 209
}

210
static void gic_bind_eic_interrupt(int irq, int set)
S
Steven J. Hill 已提交
211 212 213 214 215
{
	/* Convert irq vector # to hw int # */
	irq -= GIC_PIN_TO_VEC_OFFSET;

	/* Set irq to use shadow set */
216 217
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_EIC_SHADOW_SET_BASE) +
		  GIC_VPE_EIC_SS(irq), set);
S
Steven J. Hill 已提交
218 219
}

220 221
void gic_send_ipi(unsigned int intr)
{
222
	gic_write(GIC_REG(SHARED, GIC_SH_WEDGE), 0x80000000 | intr);
223 224
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
int gic_get_c0_compare_int(void)
{
	if (!gic_local_irq_is_routable(GIC_LOCAL_INT_TIMER))
		return MIPS_CPU_IRQ_BASE + cp0_compare_irq;
	return irq_create_mapping(gic_irq_domain,
				  GIC_LOCAL_TO_HWIRQ(GIC_LOCAL_INT_TIMER));
}

int gic_get_c0_perfcount_int(void)
{
	if (!gic_local_irq_is_routable(GIC_LOCAL_INT_PERFCTR)) {
		/* Is the erformance counter shared with the timer? */
		if (cp0_perfcount_irq < 0)
			return -1;
		return MIPS_CPU_IRQ_BASE + cp0_perfcount_irq;
	}
	return irq_create_mapping(gic_irq_domain,
				  GIC_LOCAL_TO_HWIRQ(GIC_LOCAL_INT_PERFCTR));
}

245
static unsigned int gic_get_int(void)
246 247 248
{
	unsigned int i;
	unsigned long *pending, *intrmask, *pcpu_mask;
249
	unsigned long pending_reg, intrmask_reg;
250 251 252 253 254 255

	/* Get per-cpu bitmaps */
	pending = pending_regs[smp_processor_id()].pending;
	intrmask = intrmask_regs[smp_processor_id()].intrmask;
	pcpu_mask = pcpu_masks[smp_processor_id()].pcpu_mask;

256 257
	pending_reg = GIC_REG(SHARED, GIC_SH_PEND);
	intrmask_reg = GIC_REG(SHARED, GIC_SH_MASK);
258

259
	for (i = 0; i < BITS_TO_LONGS(gic_shared_intrs); i++) {
260 261 262 263
		pending[i] = gic_read(pending_reg);
		intrmask[i] = gic_read(intrmask_reg);
		pending_reg += 0x4;
		intrmask_reg += 0x4;
264 265
	}

266 267
	bitmap_and(pending, pending, intrmask, gic_shared_intrs);
	bitmap_and(pending, pending, pcpu_mask, gic_shared_intrs);
268

269
	return find_first_bit(pending, gic_shared_intrs);
270 271
}

272
static void gic_mask_irq(struct irq_data *d)
273
{
274
	gic_reset_mask(GIC_HWIRQ_TO_SHARED(d->hwirq));
275 276
}

277
static void gic_unmask_irq(struct irq_data *d)
278
{
279
	gic_set_mask(GIC_HWIRQ_TO_SHARED(d->hwirq));
280 281
}

282 283
static void gic_ack_irq(struct irq_data *d)
{
284
	unsigned int irq = GIC_HWIRQ_TO_SHARED(d->hwirq);
285

286
	gic_write(GIC_REG(SHARED, GIC_SH_WEDGE), irq);
287 288
}

289 290
static int gic_set_type(struct irq_data *d, unsigned int type)
{
291
	unsigned int irq = GIC_HWIRQ_TO_SHARED(d->hwirq);
292 293 294 295 296 297
	unsigned long flags;
	bool is_edge;

	spin_lock_irqsave(&gic_lock, flags);
	switch (type & IRQ_TYPE_SENSE_MASK) {
	case IRQ_TYPE_EDGE_FALLING:
298 299 300
		gic_set_polarity(irq, GIC_POL_NEG);
		gic_set_trigger(irq, GIC_TRIG_EDGE);
		gic_set_dual_edge(irq, GIC_TRIG_DUAL_DISABLE);
301 302 303
		is_edge = true;
		break;
	case IRQ_TYPE_EDGE_RISING:
304 305 306
		gic_set_polarity(irq, GIC_POL_POS);
		gic_set_trigger(irq, GIC_TRIG_EDGE);
		gic_set_dual_edge(irq, GIC_TRIG_DUAL_DISABLE);
307 308 309 310
		is_edge = true;
		break;
	case IRQ_TYPE_EDGE_BOTH:
		/* polarity is irrelevant in this case */
311 312
		gic_set_trigger(irq, GIC_TRIG_EDGE);
		gic_set_dual_edge(irq, GIC_TRIG_DUAL_ENABLE);
313 314 315
		is_edge = true;
		break;
	case IRQ_TYPE_LEVEL_LOW:
316 317 318
		gic_set_polarity(irq, GIC_POL_NEG);
		gic_set_trigger(irq, GIC_TRIG_LEVEL);
		gic_set_dual_edge(irq, GIC_TRIG_DUAL_DISABLE);
319 320 321 322
		is_edge = false;
		break;
	case IRQ_TYPE_LEVEL_HIGH:
	default:
323 324 325
		gic_set_polarity(irq, GIC_POL_POS);
		gic_set_trigger(irq, GIC_TRIG_LEVEL);
		gic_set_dual_edge(irq, GIC_TRIG_DUAL_DISABLE);
326 327 328 329 330
		is_edge = false;
		break;
	}

	if (is_edge) {
331 332 333
		__irq_set_chip_handler_name_locked(d->irq,
						   &gic_edge_irq_controller,
						   handle_edge_irq, NULL);
334
	} else {
335 336 337
		__irq_set_chip_handler_name_locked(d->irq,
						   &gic_level_irq_controller,
						   handle_level_irq, NULL);
338 339
	}
	spin_unlock_irqrestore(&gic_lock, flags);
340

341 342 343 344
	return 0;
}

#ifdef CONFIG_SMP
345 346
static int gic_set_affinity(struct irq_data *d, const struct cpumask *cpumask,
			    bool force)
347
{
348
	unsigned int irq = GIC_HWIRQ_TO_SHARED(d->hwirq);
349 350 351 352
	cpumask_t	tmp = CPU_MASK_NONE;
	unsigned long	flags;
	int		i;

353
	cpumask_and(&tmp, cpumask, cpu_online_mask);
354
	if (cpus_empty(tmp))
355
		return -EINVAL;
356 357 358 359

	/* Assumption : cpumask refers to a single CPU */
	spin_lock_irqsave(&gic_lock, flags);

360
	/* Re-route this IRQ */
361
	gic_map_to_vpe(irq, first_cpu(tmp));
362 363 364 365 366

	/* Update the pcpu_masks */
	for (i = 0; i < NR_CPUS; i++)
		clear_bit(irq, pcpu_masks[i].pcpu_mask);
	set_bit(irq, pcpu_masks[first_cpu(tmp)].pcpu_mask);
367

368
	cpumask_copy(d->affinity, cpumask);
369 370
	spin_unlock_irqrestore(&gic_lock, flags);

371
	return IRQ_SET_MASK_OK_NOCOPY;
372 373 374
}
#endif

375 376 377 378 379 380 381 382 383 384 385
static struct irq_chip gic_level_irq_controller = {
	.name			=	"MIPS GIC",
	.irq_mask		=	gic_mask_irq,
	.irq_unmask		=	gic_unmask_irq,
	.irq_set_type		=	gic_set_type,
#ifdef CONFIG_SMP
	.irq_set_affinity	=	gic_set_affinity,
#endif
};

static struct irq_chip gic_edge_irq_controller = {
386
	.name			=	"MIPS GIC",
387
	.irq_ack		=	gic_ack_irq,
388 389
	.irq_mask		=	gic_mask_irq,
	.irq_unmask		=	gic_unmask_irq,
390
	.irq_set_type		=	gic_set_type,
391
#ifdef CONFIG_SMP
392
	.irq_set_affinity	=	gic_set_affinity,
393 394 395
#endif
};

396 397 398 399
static unsigned int gic_get_local_int(void)
{
	unsigned long pending, masked;

400 401
	pending = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_PEND));
	masked = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_MASK));
402 403 404 405 406 407 408 409 410 411

	bitmap_and(&pending, &pending, &masked, GIC_NUM_LOCAL_INTRS);

	return find_first_bit(&pending, GIC_NUM_LOCAL_INTRS);
}

static void gic_mask_local_irq(struct irq_data *d)
{
	int intr = GIC_HWIRQ_TO_LOCAL(d->hwirq);

412
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_RMASK), 1 << intr);
413 414 415 416 417 418
}

static void gic_unmask_local_irq(struct irq_data *d)
{
	int intr = GIC_HWIRQ_TO_LOCAL(d->hwirq);

419
	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_SMASK), 1 << intr);
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
}

static struct irq_chip gic_local_irq_controller = {
	.name			=	"MIPS GIC Local",
	.irq_mask		=	gic_mask_local_irq,
	.irq_unmask		=	gic_unmask_local_irq,
};

static void gic_mask_local_irq_all_vpes(struct irq_data *d)
{
	int intr = GIC_HWIRQ_TO_LOCAL(d->hwirq);
	int i;
	unsigned long flags;

	spin_lock_irqsave(&gic_lock, flags);
	for (i = 0; i < gic_vpes; i++) {
436 437
		gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_OTHER_ADDR), i);
		gic_write(GIC_REG(VPE_OTHER, GIC_VPE_RMASK), 1 << intr);
438 439 440 441 442 443 444 445 446 447 448 449
	}
	spin_unlock_irqrestore(&gic_lock, flags);
}

static void gic_unmask_local_irq_all_vpes(struct irq_data *d)
{
	int intr = GIC_HWIRQ_TO_LOCAL(d->hwirq);
	int i;
	unsigned long flags;

	spin_lock_irqsave(&gic_lock, flags);
	for (i = 0; i < gic_vpes; i++) {
450 451
		gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_OTHER_ADDR), i);
		gic_write(GIC_REG(VPE_OTHER, GIC_VPE_SMASK), 1 << intr);
452 453 454 455 456 457 458 459 460 461
	}
	spin_unlock_irqrestore(&gic_lock, flags);
}

static struct irq_chip gic_all_vpes_local_irq_controller = {
	.name			=	"MIPS GIC Local",
	.irq_mask		=	gic_mask_local_irq_all_vpes,
	.irq_unmask		=	gic_unmask_local_irq_all_vpes,
};

462
static void __gic_irq_dispatch(void)
463
{
464
	unsigned int intr, virq;
J
Jeffrey Deans 已提交
465

466 467 468 469 470 471
	while ((intr = gic_get_local_int()) != GIC_NUM_LOCAL_INTRS) {
		virq = irq_linear_revmap(gic_irq_domain,
					 GIC_LOCAL_TO_HWIRQ(intr));
		do_IRQ(virq);
	}

472
	while ((intr = gic_get_int()) != gic_shared_intrs) {
473 474
		virq = irq_linear_revmap(gic_irq_domain,
					 GIC_SHARED_TO_HWIRQ(intr));
475
		do_IRQ(virq);
476
	}
477
}
478

479 480 481 482 483 484 485 486 487 488 489 490 491
static void gic_irq_dispatch(unsigned int irq, struct irq_desc *desc)
{
	__gic_irq_dispatch();
}

#ifdef CONFIG_MIPS_GIC_IPI
static int gic_resched_int_base;
static int gic_call_int_base;

unsigned int plat_ipi_resched_int_xlate(unsigned int cpu)
{
	return gic_resched_int_base + cpu;
}
492

493 494 495 496
unsigned int plat_ipi_call_int_xlate(unsigned int cpu)
{
	return gic_call_int_base + cpu;
}
497

498 499 500 501 502 503 504 505 506 507 508 509 510
static irqreturn_t ipi_resched_interrupt(int irq, void *dev_id)
{
	scheduler_ipi();

	return IRQ_HANDLED;
}

static irqreturn_t ipi_call_interrupt(int irq, void *dev_id)
{
	smp_call_function_interrupt();

	return IRQ_HANDLED;
}
J
Jeffrey Deans 已提交
511

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
static struct irqaction irq_resched = {
	.handler	= ipi_resched_interrupt,
	.flags		= IRQF_PERCPU,
	.name		= "IPI resched"
};

static struct irqaction irq_call = {
	.handler	= ipi_call_interrupt,
	.flags		= IRQF_PERCPU,
	.name		= "IPI call"
};

static __init void gic_ipi_init_one(unsigned int intr, int cpu,
				    struct irqaction *action)
{
527 528
	int virq = irq_create_mapping(gic_irq_domain,
				      GIC_SHARED_TO_HWIRQ(intr));
529 530
	int i;

531
	gic_map_to_vpe(intr, cpu);
532 533
	for (i = 0; i < NR_CPUS; i++)
		clear_bit(intr, pcpu_masks[i].pcpu_mask);
J
Jeffrey Deans 已提交
534 535
	set_bit(intr, pcpu_masks[cpu].pcpu_mask);

536 537 538 539
	irq_set_irq_type(virq, IRQ_TYPE_EDGE_RISING);

	irq_set_handler(virq, handle_percpu_irq);
	setup_irq(virq, action);
540 541
}

542
static __init void gic_ipi_init(void)
543
{
544 545 546
	int i;

	/* Use last 2 * NR_CPUS interrupts as IPIs */
547
	gic_resched_int_base = gic_shared_intrs - nr_cpu_ids;
548 549 550 551 552 553 554 555 556 557 558 559 560
	gic_call_int_base = gic_resched_int_base - nr_cpu_ids;

	for (i = 0; i < nr_cpu_ids; i++) {
		gic_ipi_init_one(gic_call_int_base + i, i, &irq_call);
		gic_ipi_init_one(gic_resched_int_base + i, i, &irq_resched);
	}
}
#else
static inline void gic_ipi_init(void)
{
}
#endif

561
static void __init gic_basic_init(void)
562 563
{
	unsigned int i;
S
Steven J. Hill 已提交
564 565

	board_bind_eic_interrupt = &gic_bind_eic_interrupt;
566 567

	/* Setup defaults */
568
	for (i = 0; i < gic_shared_intrs; i++) {
569 570 571
		gic_set_polarity(i, GIC_POL_POS);
		gic_set_trigger(i, GIC_TRIG_LEVEL);
		gic_reset_mask(i);
572 573
	}

574 575 576
	for (i = 0; i < gic_vpes; i++) {
		unsigned int j;

577
		gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_OTHER_ADDR), i);
578 579 580
		for (j = 0; j < GIC_NUM_LOCAL_INTRS; j++) {
			if (!gic_local_irq_is_routable(j))
				continue;
581
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_RMASK), 1 << j);
582 583
		}
	}
584 585
}

586 587
static int gic_local_irq_domain_map(struct irq_domain *d, unsigned int virq,
				    irq_hw_number_t hw)
588
{
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
	int intr = GIC_HWIRQ_TO_LOCAL(hw);
	int ret = 0;
	int i;
	unsigned long flags;

	if (!gic_local_irq_is_routable(intr))
		return -EPERM;

	/*
	 * HACK: These are all really percpu interrupts, but the rest
	 * of the MIPS kernel code does not use the percpu IRQ API for
	 * the CP0 timer and performance counter interrupts.
	 */
	if (intr != GIC_LOCAL_INT_TIMER && intr != GIC_LOCAL_INT_PERFCTR) {
		irq_set_chip_and_handler(virq,
					 &gic_local_irq_controller,
					 handle_percpu_devid_irq);
		irq_set_percpu_devid(virq);
	} else {
		irq_set_chip_and_handler(virq,
					 &gic_all_vpes_local_irq_controller,
					 handle_percpu_irq);
	}

	spin_lock_irqsave(&gic_lock, flags);
	for (i = 0; i < gic_vpes; i++) {
		u32 val = GIC_MAP_TO_PIN_MSK | gic_cpu_pin;

617
		gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_OTHER_ADDR), i);
618 619 620

		switch (intr) {
		case GIC_LOCAL_INT_WD:
621
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_WD_MAP), val);
622 623
			break;
		case GIC_LOCAL_INT_COMPARE:
624
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_COMPARE_MAP), val);
625 626
			break;
		case GIC_LOCAL_INT_TIMER:
627
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_TIMER_MAP), val);
628 629
			break;
		case GIC_LOCAL_INT_PERFCTR:
630
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_PERFCTR_MAP), val);
631 632
			break;
		case GIC_LOCAL_INT_SWINT0:
633
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_SWINT0_MAP), val);
634 635
			break;
		case GIC_LOCAL_INT_SWINT1:
636
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_SWINT1_MAP), val);
637 638
			break;
		case GIC_LOCAL_INT_FDC:
639
			gic_write(GIC_REG(VPE_OTHER, GIC_VPE_FDC_MAP), val);
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
			break;
		default:
			pr_err("Invalid local IRQ %d\n", intr);
			ret = -EINVAL;
			break;
		}
	}
	spin_unlock_irqrestore(&gic_lock, flags);

	return ret;
}

static int gic_shared_irq_domain_map(struct irq_domain *d, unsigned int virq,
				     irq_hw_number_t hw)
{
	int intr = GIC_HWIRQ_TO_SHARED(hw);
656 657
	unsigned long flags;

658 659
	irq_set_chip_and_handler(virq, &gic_level_irq_controller,
				 handle_level_irq);
660 661

	spin_lock_irqsave(&gic_lock, flags);
662
	gic_map_to_pin(intr, gic_cpu_pin);
663
	/* Map to VPE 0 by default */
664
	gic_map_to_vpe(intr, 0);
665
	set_bit(intr, pcpu_masks[0].pcpu_mask);
666 667 668 669 670
	spin_unlock_irqrestore(&gic_lock, flags);

	return 0;
}

671 672 673 674 675 676 677 678
static int gic_irq_domain_map(struct irq_domain *d, unsigned int virq,
			      irq_hw_number_t hw)
{
	if (GIC_HWIRQ_TO_LOCAL(hw) < GIC_NUM_LOCAL_INTRS)
		return gic_local_irq_domain_map(d, virq, hw);
	return gic_shared_irq_domain_map(d, virq, hw);
}

679 680 681 682 683
static struct irq_domain_ops gic_irq_domain_ops = {
	.map = gic_irq_domain_map,
	.xlate = irq_domain_xlate_twocell,
};

684
void __init gic_init(unsigned long gic_base_addr,
685
		     unsigned long gic_addrspace_size, unsigned int cpu_vec,
686 687 688 689
		     unsigned int irqbase)
{
	unsigned int gicconfig;

690
	gic_base = ioremap_nocache(gic_base_addr, gic_addrspace_size);
691

692
	gicconfig = gic_read(GIC_REG(SHARED, GIC_SH_CONFIG));
693
	gic_shared_intrs = (gicconfig & GIC_SH_CONFIG_NUMINTRS_MSK) >>
694
		   GIC_SH_CONFIG_NUMINTRS_SHF;
695
	gic_shared_intrs = ((gic_shared_intrs + 1) * 8);
696

697
	gic_vpes = (gicconfig & GIC_SH_CONFIG_NUMVPES_MSK) >>
698
		  GIC_SH_CONFIG_NUMVPES_SHF;
699
	gic_vpes = gic_vpes + 1;
700

701 702 703 704 705 706 707 708 709 710 711
	if (cpu_has_veic) {
		/* Always use vector 1 in EIC mode */
		gic_cpu_pin = 0;
		set_vi_handler(gic_cpu_pin + GIC_PIN_TO_VEC_OFFSET,
			       __gic_irq_dispatch);
	} else {
		gic_cpu_pin = cpu_vec - GIC_CPU_PIN_OFFSET;
		irq_set_chained_handler(MIPS_CPU_IRQ_BASE + cpu_vec,
					gic_irq_dispatch);
	}

712 713
	gic_irq_domain = irq_domain_add_simple(NULL, GIC_NUM_LOCAL_INTRS +
					       gic_shared_intrs, irqbase,
714 715 716
					       &gic_irq_domain_ops, NULL);
	if (!gic_irq_domain)
		panic("Failed to add GIC IRQ domain");
717

718
	gic_basic_init();
719 720

	gic_ipi_init();
721
}