vector.c 19.3 KB
Newer Older
1 2 3 4 5
/*
 * Local APIC related interfaces to support IOAPIC, MSI, HT_IRQ etc.
 *
 * Copyright (C) 1997, 1998, 1999, 2000, 2009 Ingo Molnar, Hajnalka Szabo
 *	Moved from arch/x86/kernel/apic/io_apic.c.
6 7
 * Jiang Liu <jiang.liu@linux.intel.com>
 *	Enable support of hierarchical irqdomains
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * 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.
 */
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/compiler.h>
#include <linux/irqdomain.h>
#include <linux/slab.h>
#include <asm/hw_irq.h>
#include <asm/apic.h>
#include <asm/i8259.h>
#include <asm/desc.h>
#include <asm/irq_remapping.h>

24 25 26 27 28 29 30
struct apic_chip_data {
	struct irq_cfg		cfg;
	cpumask_var_t		domain;
	cpumask_var_t		old_domain;
	u8			move_in_progress : 1;
};

31
struct irq_domain *x86_vector_domain;
32
static DEFINE_RAW_SPINLOCK(vector_lock);
33
static struct irq_chip lapic_controller;
34
#ifdef	CONFIG_X86_IO_APIC
35
static struct apic_chip_data *legacy_irq_data[NR_IRQS_LEGACY];
36
#endif
37 38 39 40 41 42 43 44 45 46 47 48 49 50

void lock_vector_lock(void)
{
	/* Used to the online set of cpus does not change
	 * during assign_irq_vector.
	 */
	raw_spin_lock(&vector_lock);
}

void unlock_vector_lock(void)
{
	raw_spin_unlock(&vector_lock);
}

51
static struct apic_chip_data *apic_chip_data(struct irq_data *irq_data)
52
{
53 54 55 56 57 58
	if (!irq_data)
		return NULL;

	while (irq_data->parent_data)
		irq_data = irq_data->parent_data;

59 60 61
	return irq_data->chip_data;
}

62 63 64 65 66 67 68 69
struct irq_cfg *irqd_cfg(struct irq_data *irq_data)
{
	struct apic_chip_data *data = apic_chip_data(irq_data);

	return data ? &data->cfg : NULL;
}

struct irq_cfg *irq_cfg(unsigned int irq)
70
{
71 72
	return irqd_cfg(irq_get_irq_data(irq));
}
73

74 75 76 77 78 79
static struct apic_chip_data *alloc_apic_chip_data(int node)
{
	struct apic_chip_data *data;

	data = kzalloc_node(sizeof(*data), GFP_KERNEL, node);
	if (!data)
80
		return NULL;
81 82 83
	if (!zalloc_cpumask_var_node(&data->domain, GFP_KERNEL, node))
		goto out_data;
	if (!zalloc_cpumask_var_node(&data->old_domain, GFP_KERNEL, node))
84
		goto out_domain;
85
	return data;
86
out_domain:
87 88 89
	free_cpumask_var(data->domain);
out_data:
	kfree(data);
90 91 92
	return NULL;
}

93
static void free_apic_chip_data(struct apic_chip_data *data)
94
{
95 96 97 98
	if (data) {
		free_cpumask_var(data->domain);
		free_cpumask_var(data->old_domain);
		kfree(data);
99
	}
100 101
}

102 103
static int __assign_irq_vector(int irq, struct apic_chip_data *d,
			       const struct cpumask *mask)
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
{
	/*
	 * NOTE! The local APIC isn't very good at handling
	 * multiple interrupts at the same interrupt level.
	 * As the interrupt level is determined by taking the
	 * vector number and shifting that right by 4, we
	 * want to spread these out a bit so that they don't
	 * all fall in the same interrupt level.
	 *
	 * Also, we've got to be careful not to trash gate
	 * 0x80, because int 0x80 is hm, kind of importantish. ;)
	 */
	static int current_vector = FIRST_EXTERNAL_VECTOR + VECTOR_OFFSET_START;
	static int current_offset = VECTOR_OFFSET_START % 16;
	int cpu, err;
	cpumask_var_t tmp_mask;

121
	if (d->move_in_progress)
122 123 124 125 126 127 128
		return -EBUSY;

	if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
		return -ENOMEM;

	/* Only try and allocate irqs on cpus that are present */
	err = -ENOSPC;
129
	cpumask_clear(d->old_domain);
130 131 132 133 134 135
	cpu = cpumask_first_and(mask, cpu_online_mask);
	while (cpu < nr_cpu_ids) {
		int new_cpu, vector, offset;

		apic->vector_allocation_domain(cpu, tmp_mask, mask);

136
		if (cpumask_subset(tmp_mask, d->domain)) {
137
			err = 0;
138
			if (cpumask_equal(tmp_mask, d->domain))
139 140 141 142 143 144
				break;
			/*
			 * New cpumask using the vector is a proper subset of
			 * the current in use mask. So cleanup the vector
			 * allocation for the members that are not used anymore.
			 */
145 146 147 148
			cpumask_andnot(d->old_domain, d->domain, tmp_mask);
			d->move_in_progress =
			   cpumask_intersects(d->old_domain, cpu_online_mask);
			cpumask_and(d->domain, d->domain, tmp_mask);
149 150 151 152 153 154 155 156 157 158 159 160 161
			break;
		}

		vector = current_vector;
		offset = current_offset;
next:
		vector += 16;
		if (vector >= first_system_vector) {
			offset = (offset + 1) % 16;
			vector = FIRST_EXTERNAL_VECTOR + offset;
		}

		if (unlikely(current_vector == vector)) {
162 163
			cpumask_or(d->old_domain, d->old_domain, tmp_mask);
			cpumask_andnot(tmp_mask, mask, d->old_domain);
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
			cpu = cpumask_first_and(tmp_mask, cpu_online_mask);
			continue;
		}

		if (test_bit(vector, used_vectors))
			goto next;

		for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask) {
			if (per_cpu(vector_irq, new_cpu)[vector] >
			    VECTOR_UNDEFINED)
				goto next;
		}
		/* Found one! */
		current_vector = vector;
		current_offset = offset;
179 180 181 182
		if (d->cfg.vector) {
			cpumask_copy(d->old_domain, d->domain);
			d->move_in_progress =
			   cpumask_intersects(d->old_domain, cpu_online_mask);
183 184 185
		}
		for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
			per_cpu(vector_irq, new_cpu)[vector] = irq;
186 187
		d->cfg.vector = vector;
		cpumask_copy(d->domain, tmp_mask);
188 189 190 191 192
		err = 0;
		break;
	}
	free_cpumask_var(tmp_mask);

193 194
	if (!err) {
		/* cache destination APIC IDs into cfg->dest_apicid */
195 196
		err = apic->cpu_mask_to_apicid_and(mask, d->domain,
						   &d->cfg.dest_apicid);
197 198
	}

199 200 201
	return err;
}

202
static int assign_irq_vector(int irq, struct apic_chip_data *data,
203
			     const struct cpumask *mask)
204 205 206 207 208
{
	int err;
	unsigned long flags;

	raw_spin_lock_irqsave(&vector_lock, flags);
209
	err = __assign_irq_vector(irq, data, mask);
210 211 212 213
	raw_spin_unlock_irqrestore(&vector_lock, flags);
	return err;
}

214
static void clear_irq_vector(int irq, struct apic_chip_data *data)
215 216 217 218 219
{
	int cpu, vector;
	unsigned long flags;

	raw_spin_lock_irqsave(&vector_lock, flags);
220
	BUG_ON(!data->cfg.vector);
221

222 223
	vector = data->cfg.vector;
	for_each_cpu_and(cpu, data->domain, cpu_online_mask)
224 225
		per_cpu(vector_irq, cpu)[vector] = VECTOR_UNDEFINED;

226 227
	data->cfg.vector = 0;
	cpumask_clear(data->domain);
228

229
	if (likely(!data->move_in_progress)) {
230 231 232 233
		raw_spin_unlock_irqrestore(&vector_lock, flags);
		return;
	}

234
	for_each_cpu_and(cpu, data->old_domain, cpu_online_mask) {
235 236 237 238 239 240 241 242
		for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
		     vector++) {
			if (per_cpu(vector_irq, cpu)[vector] != irq)
				continue;
			per_cpu(vector_irq, cpu)[vector] = VECTOR_UNDEFINED;
			break;
		}
	}
243
	data->move_in_progress = 0;
244 245 246
	raw_spin_unlock_irqrestore(&vector_lock, flags);
}

247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
void init_irq_alloc_info(struct irq_alloc_info *info,
			 const struct cpumask *mask)
{
	memset(info, 0, sizeof(*info));
	info->mask = mask;
}

void copy_irq_alloc_info(struct irq_alloc_info *dst, struct irq_alloc_info *src)
{
	if (src)
		*dst = *src;
	else
		memset(dst, 0, sizeof(*dst));
}

static inline const struct cpumask *
irq_alloc_info_get_mask(struct irq_alloc_info *info)
{
	return (!info || !info->mask) ? apic->target_cpus() : info->mask;
}

static void x86_vector_free_irqs(struct irq_domain *domain,
				 unsigned int virq, unsigned int nr_irqs)
{
	struct irq_data *irq_data;
	int i;

	for (i = 0; i < nr_irqs; i++) {
		irq_data = irq_domain_get_irq_data(x86_vector_domain, virq + i);
		if (irq_data && irq_data->chip_data) {
			clear_irq_vector(virq + i, irq_data->chip_data);
278
			free_apic_chip_data(irq_data->chip_data);
279 280
#ifdef	CONFIG_X86_IO_APIC
			if (virq + i < nr_legacy_irqs())
281
				legacy_irq_data[virq + i] = NULL;
282
#endif
283 284 285 286 287 288 289 290 291
			irq_domain_reset_irq_data(irq_data);
		}
	}
}

static int x86_vector_alloc_irqs(struct irq_domain *domain, unsigned int virq,
				 unsigned int nr_irqs, void *arg)
{
	struct irq_alloc_info *info = arg;
292
	struct apic_chip_data *data;
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
	const struct cpumask *mask;
	struct irq_data *irq_data;
	int i, err;

	if (disable_apic)
		return -ENXIO;

	/* Currently vector allocator can't guarantee contiguous allocations */
	if ((info->flags & X86_IRQ_ALLOC_CONTIGUOUS_VECTORS) && nr_irqs > 1)
		return -ENOSYS;

	mask = irq_alloc_info_get_mask(info);
	for (i = 0; i < nr_irqs; i++) {
		irq_data = irq_domain_get_irq_data(domain, virq + i);
		BUG_ON(!irq_data);
308
#ifdef	CONFIG_X86_IO_APIC
309 310
		if (virq + i < nr_legacy_irqs() && legacy_irq_data[virq + i])
			data = legacy_irq_data[virq + i];
311 312
		else
#endif
313 314
			data = alloc_apic_chip_data(irq_data->node);
		if (!data) {
315 316 317 318 319
			err = -ENOMEM;
			goto error;
		}

		irq_data->chip = &lapic_controller;
320
		irq_data->chip_data = data;
321
		irq_data->hwirq = virq + i;
322
		err = assign_irq_vector(virq, data, mask);
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
		if (err)
			goto error;
	}

	return 0;

error:
	x86_vector_free_irqs(domain, virq, i + 1);
	return err;
}

static struct irq_domain_ops x86_vector_domain_ops = {
	.alloc = x86_vector_alloc_irqs,
	.free = x86_vector_free_irqs,
};

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
int __init arch_probe_nr_irqs(void)
{
	int nr;

	if (nr_irqs > (NR_VECTORS * nr_cpu_ids))
		nr_irqs = NR_VECTORS * nr_cpu_ids;

	nr = (gsi_top + nr_legacy_irqs()) + 8 * nr_cpu_ids;
#if defined(CONFIG_PCI_MSI) || defined(CONFIG_HT_IRQ)
	/*
	 * for MSI and HT dyn irq
	 */
	if (gsi_top <= NR_IRQS_LEGACY)
		nr +=  8 * nr_cpu_ids;
	else
		nr += gsi_top * 16;
#endif
	if (nr < nr_irqs)
		nr_irqs = nr;

	return nr_legacy_irqs();
}

362 363 364 365
#ifdef	CONFIG_X86_IO_APIC
static void init_legacy_irqs(void)
{
	int i, node = cpu_to_node(0);
366
	struct apic_chip_data *data;
367 368 369 370 371 372

	/*
	 * For legacy IRQ's, start with assigning irq0 to irq15 to
	 * IRQ0_VECTOR to IRQ15_VECTOR for all cpu's.
	 */
	for (i = 0; i < nr_legacy_irqs(); i++) {
373 374
		data = legacy_irq_data[i] = alloc_apic_chip_data(node);
		BUG_ON(!data);
375 376 377 378
		/*
		 * For legacy IRQ's, start with assigning irq0 to irq15 to
		 * IRQ0_VECTOR to IRQ15_VECTOR for all cpu's.
		 */
379 380 381
		data->cfg.vector = IRQ0_VECTOR + i;
		cpumask_setall(data->domain);
		irq_set_chip_data(i, data);
382 383 384 385 386 387
	}
}
#else
static void init_legacy_irqs(void) { }
#endif

388 389
int __init arch_early_irq_init(void)
{
390 391
	init_legacy_irqs();

392 393 394 395 396
	x86_vector_domain = irq_domain_add_tree(NULL, &x86_vector_domain_ops,
						NULL);
	BUG_ON(x86_vector_domain == NULL);
	irq_set_default_host(x86_vector_domain);

397
	arch_init_msi_domain(x86_vector_domain);
398
	arch_init_htirq_domain(x86_vector_domain);
399

400 401 402
	return arch_early_ioapic_init();
}

403 404 405 406
static void __setup_vector_irq(int cpu)
{
	/* Initialize vector_irq on a new cpu */
	int irq, vector;
407
	struct apic_chip_data *data;
408 409 410 411 412 413 414 415 416

	/*
	 * vector_lock will make sure that we don't run into irq vector
	 * assignments that might be happening on another cpu in parallel,
	 * while we setup our initial vector to irq mappings.
	 */
	raw_spin_lock(&vector_lock);
	/* Mark the inuse vectors */
	for_each_active_irq(irq) {
417 418
		data = apic_chip_data(irq_get_irq_data(irq));
		if (!data)
419 420
			continue;

421
		if (!cpumask_test_cpu(cpu, data->domain))
422
			continue;
423
		vector = data->cfg.vector;
424 425 426 427 428 429 430 431
		per_cpu(vector_irq, cpu)[vector] = irq;
	}
	/* Mark the free vectors */
	for (vector = 0; vector < NR_VECTORS; ++vector) {
		irq = per_cpu(vector_irq, cpu)[vector];
		if (irq <= VECTOR_UNDEFINED)
			continue;

432 433
		data = apic_chip_data(irq_get_irq_data(irq));
		if (!cpumask_test_cpu(cpu, data->domain))
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
			per_cpu(vector_irq, cpu)[vector] = VECTOR_UNDEFINED;
	}
	raw_spin_unlock(&vector_lock);
}

/*
 * Setup the vector to irq mappings.
 */
void setup_vector_irq(int cpu)
{
	int irq;

	/*
	 * On most of the platforms, legacy PIC delivers the interrupts on the
	 * boot cpu. But there are certain platforms where PIC interrupts are
	 * delivered to multiple cpu's. If the legacy IRQ is handled by the
	 * legacy PIC, for the new cpu that is coming online, setup the static
	 * legacy vector to irq mapping:
	 */
	for (irq = 0; irq < nr_legacy_irqs(); irq++)
		per_cpu(vector_irq, cpu)[IRQ0_VECTOR + irq] = irq;

	__setup_vector_irq(cpu);
}

459
static int apic_retrigger_irq(struct irq_data *irq_data)
460
{
461
	struct apic_chip_data *data = apic_chip_data(irq_data);
462 463 464 465
	unsigned long flags;
	int cpu;

	raw_spin_lock_irqsave(&vector_lock, flags);
466 467
	cpu = cpumask_first_and(data->domain, cpu_online_mask);
	apic->send_IPI_mask(cpumask_of(cpu), data->cfg.vector);
468 469 470 471 472 473 474
	raw_spin_unlock_irqrestore(&vector_lock, flags);

	return 1;
}

void apic_ack_edge(struct irq_data *data)
{
475
	irq_complete_move(irqd_cfg(data));
476 477 478 479
	irq_move_irq(data);
	ack_APIC_irq();
}

480 481
static int apic_set_affinity(struct irq_data *irq_data,
			     const struct cpumask *dest, bool force)
482
{
483
	struct apic_chip_data *data = irq_data->chip_data;
484 485 486 487 488 489 490 491
	int err, irq = irq_data->irq;

	if (!config_enabled(CONFIG_SMP))
		return -EPERM;

	if (!cpumask_intersects(dest, cpu_online_mask))
		return -EINVAL;

492
	err = assign_irq_vector(irq, data, dest);
493 494 495
	if (err) {
		struct irq_data *top = irq_get_irq_data(irq);

496
		if (assign_irq_vector(irq, data, top->affinity))
497 498 499 500 501 502 503 504 505
			pr_err("Failed to recover vector for irq %d\n", irq);
		return err;
	}

	return IRQ_SET_MASK_OK;
}

static struct irq_chip lapic_controller = {
	.irq_ack		= apic_ack_edge,
506
	.irq_set_affinity	= apic_set_affinity,
507 508 509
	.irq_retrigger		= apic_retrigger_irq,
};

510
#ifdef CONFIG_SMP
511
static void __send_cleanup_vector(struct apic_chip_data *data)
512 513 514 515 516 517
{
	cpumask_var_t cleanup_mask;

	if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
		unsigned int i;

518
		for_each_cpu_and(i, data->old_domain, cpu_online_mask)
519 520 521
			apic->send_IPI_mask(cpumask_of(i),
					    IRQ_MOVE_CLEANUP_VECTOR);
	} else {
522
		cpumask_and(cleanup_mask, data->old_domain, cpu_online_mask);
523 524 525
		apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
		free_cpumask_var(cleanup_mask);
	}
526
	data->move_in_progress = 0;
527 528
}

529 530
void send_cleanup_vector(struct irq_cfg *cfg)
{
531 532 533 534 535
	struct apic_chip_data *data;

	data = container_of(cfg, struct apic_chip_data, cfg);
	if (data->move_in_progress)
		__send_cleanup_vector(data);
536 537
}

538 539 540 541 542 543 544 545 546 547 548 549 550
asmlinkage __visible void smp_irq_move_cleanup_interrupt(void)
{
	unsigned vector, me;

	ack_APIC_irq();
	irq_enter();
	exit_idle();

	me = smp_processor_id();
	for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
		int irq;
		unsigned int irr;
		struct irq_desc *desc;
551
		struct apic_chip_data *data;
552 553 554 555 556 557 558 559 560 561

		irq = __this_cpu_read(vector_irq[vector]);

		if (irq <= VECTOR_UNDEFINED)
			continue;

		desc = irq_to_desc(irq);
		if (!desc)
			continue;

562 563
		data = apic_chip_data(&desc->irq_data);
		if (!data)
564 565 566 567 568 569 570 571
			continue;

		raw_spin_lock(&desc->lock);

		/*
		 * Check if the irq migration is in progress. If so, we
		 * haven't received the cleanup request yet for this irq.
		 */
572
		if (data->move_in_progress)
573 574
			goto unlock;

575 576
		if (vector == data->cfg.vector &&
		    cpumask_test_cpu(me, data->domain))
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
			goto unlock;

		irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
		/*
		 * Check if the vector that needs to be cleanedup is
		 * registered at the cpu's IRR. If so, then this is not
		 * the best time to clean it up. Lets clean it up in the
		 * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
		 * to myself.
		 */
		if (irr  & (1 << (vector % 32))) {
			apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
			goto unlock;
		}
		__this_cpu_write(vector_irq[vector], VECTOR_UNDEFINED);
unlock:
		raw_spin_unlock(&desc->lock);
	}

	irq_exit();
}

static void __irq_complete_move(struct irq_cfg *cfg, unsigned vector)
{
	unsigned me;
602
	struct apic_chip_data *data;
603

604 605
	data = container_of(cfg, struct apic_chip_data, cfg);
	if (likely(!data->move_in_progress))
606 607 608
		return;

	me = smp_processor_id();
609 610
	if (vector == data->cfg.vector && cpumask_test_cpu(me, data->domain))
		__send_cleanup_vector(data);
611 612 613 614 615 616 617 618 619 620 621
}

void irq_complete_move(struct irq_cfg *cfg)
{
	__irq_complete_move(cfg, ~get_irq_regs()->orig_ax);
}

void irq_force_complete_move(int irq)
{
	struct irq_cfg *cfg = irq_cfg(irq);

622 623
	if (cfg)
		__irq_complete_move(cfg, cfg->vector);
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
}
#endif

static void __init print_APIC_field(int base)
{
	int i;

	printk(KERN_DEBUG);

	for (i = 0; i < 8; i++)
		pr_cont("%08x", apic_read(base + i*0x10));

	pr_cont("\n");
}

static void __init print_local_APIC(void *dummy)
{
	unsigned int i, v, ver, maxlvt;
	u64 icr;

644 645
	pr_debug("printing local APIC contents on CPU#%d/%d:\n",
		 smp_processor_id(), hard_smp_processor_id());
646
	v = apic_read(APIC_ID);
647
	pr_info("... APIC ID:      %08x (%01x)\n", v, read_apic_id());
648
	v = apic_read(APIC_LVR);
649
	pr_info("... APIC VERSION: %08x\n", v);
650 651 652 653
	ver = GET_APIC_VERSION(v);
	maxlvt = lapic_get_maxlvt();

	v = apic_read(APIC_TASKPRI);
654
	pr_debug("... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
655 656 657 658 659

	/* !82489DX */
	if (APIC_INTEGRATED(ver)) {
		if (!APIC_XAPIC(ver)) {
			v = apic_read(APIC_ARBPRI);
660 661
			pr_debug("... APIC ARBPRI: %08x (%02x)\n",
				 v, v & APIC_ARBPRI_MASK);
662 663
		}
		v = apic_read(APIC_PROCPRI);
664
		pr_debug("... APIC PROCPRI: %08x\n", v);
665 666 667 668 669 670 671 672
	}

	/*
	 * Remote read supported only in the 82489DX and local APIC for
	 * Pentium processors.
	 */
	if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
		v = apic_read(APIC_RRR);
673
		pr_debug("... APIC RRR: %08x\n", v);
674 675 676
	}

	v = apic_read(APIC_LDR);
677
	pr_debug("... APIC LDR: %08x\n", v);
678 679
	if (!x2apic_enabled()) {
		v = apic_read(APIC_DFR);
680
		pr_debug("... APIC DFR: %08x\n", v);
681 682
	}
	v = apic_read(APIC_SPIV);
683
	pr_debug("... APIC SPIV: %08x\n", v);
684

685
	pr_debug("... APIC ISR field:\n");
686
	print_APIC_field(APIC_ISR);
687
	pr_debug("... APIC TMR field:\n");
688
	print_APIC_field(APIC_TMR);
689
	pr_debug("... APIC IRR field:\n");
690 691 692 693 694 695 696 697 698
	print_APIC_field(APIC_IRR);

	/* !82489DX */
	if (APIC_INTEGRATED(ver)) {
		/* Due to the Pentium erratum 3AP. */
		if (maxlvt > 3)
			apic_write(APIC_ESR, 0);

		v = apic_read(APIC_ESR);
699
		pr_debug("... APIC ESR: %08x\n", v);
700 701 702
	}

	icr = apic_icr_read();
703 704
	pr_debug("... APIC ICR: %08x\n", (u32)icr);
	pr_debug("... APIC ICR2: %08x\n", (u32)(icr >> 32));
705 706

	v = apic_read(APIC_LVTT);
707
	pr_debug("... APIC LVTT: %08x\n", v);
708 709 710 711

	if (maxlvt > 3) {
		/* PC is LVT#4. */
		v = apic_read(APIC_LVTPC);
712
		pr_debug("... APIC LVTPC: %08x\n", v);
713 714
	}
	v = apic_read(APIC_LVT0);
715
	pr_debug("... APIC LVT0: %08x\n", v);
716
	v = apic_read(APIC_LVT1);
717
	pr_debug("... APIC LVT1: %08x\n", v);
718 719 720 721

	if (maxlvt > 2) {
		/* ERR is LVT#3. */
		v = apic_read(APIC_LVTERR);
722
		pr_debug("... APIC LVTERR: %08x\n", v);
723 724 725
	}

	v = apic_read(APIC_TMICT);
726
	pr_debug("... APIC TMICT: %08x\n", v);
727
	v = apic_read(APIC_TMCCT);
728
	pr_debug("... APIC TMCCT: %08x\n", v);
729
	v = apic_read(APIC_TDCR);
730
	pr_debug("... APIC TDCR: %08x\n", v);
731 732 733 734

	if (boot_cpu_has(X86_FEATURE_EXTAPIC)) {
		v = apic_read(APIC_EFEAT);
		maxlvt = (v >> 16) & 0xff;
735
		pr_debug("... APIC EFEAT: %08x\n", v);
736
		v = apic_read(APIC_ECTRL);
737
		pr_debug("... APIC ECTRL: %08x\n", v);
738 739
		for (i = 0; i < maxlvt; i++) {
			v = apic_read(APIC_EILVTn(i));
740
			pr_debug("... APIC EILVT%d: %08x\n", i, v);
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
		}
	}
	pr_cont("\n");
}

static void __init print_local_APICs(int maxcpu)
{
	int cpu;

	if (!maxcpu)
		return;

	preempt_disable();
	for_each_online_cpu(cpu) {
		if (cpu >= maxcpu)
			break;
		smp_call_function_single(cpu, print_local_APIC, NULL, 1);
	}
	preempt_enable();
}

static void __init print_PIC(void)
{
	unsigned int v;
	unsigned long flags;

	if (!nr_legacy_irqs())
		return;

770
	pr_debug("\nprinting PIC contents\n");
771 772 773 774

	raw_spin_lock_irqsave(&i8259A_lock, flags);

	v = inb(0xa1) << 8 | inb(0x21);
775
	pr_debug("... PIC  IMR: %04x\n", v);
776 777

	v = inb(0xa0) << 8 | inb(0x20);
778
	pr_debug("... PIC  IRR: %04x\n", v);
779 780 781 782 783 784 785 786 787

	outb(0x0b, 0xa0);
	outb(0x0b, 0x20);
	v = inb(0xa0) << 8 | inb(0x20);
	outb(0x0a, 0xa0);
	outb(0x0a, 0x20);

	raw_spin_unlock_irqrestore(&i8259A_lock, flags);

788
	pr_debug("... PIC  ISR: %04x\n", v);
789 790

	v = inb(0x4d1) << 8 | inb(0x4d0);
791
	pr_debug("... PIC ELCR: %04x\n", v);
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
}

static int show_lapic __initdata = 1;
static __init int setup_show_lapic(char *arg)
{
	int num = -1;

	if (strcmp(arg, "all") == 0) {
		show_lapic = CONFIG_NR_CPUS;
	} else {
		get_option(&arg, &num);
		if (num >= 0)
			show_lapic = num;
	}

	return 1;
}
__setup("show_lapic=", setup_show_lapic);

static int __init print_ICs(void)
{
	if (apic_verbosity == APIC_QUIET)
		return 0;

	print_PIC();

	/* don't print out if apic is not there */
	if (!cpu_has_apic && !apic_from_smp_config())
		return 0;

	print_local_APICs(show_lapic);
	print_IO_APICs();

	return 0;
}

late_initcall(print_ICs);