interrupt.c 18.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 *  PS3 interrupt routines.
 *
 *  Copyright (C) 2006 Sony Computer Entertainment Inc.
 *  Copyright 2006 Sony Corp.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/irq.h>

#include <asm/machdep.h>
#include <asm/udbg.h>
#include <asm/lv1call.h>

#include "platform.h"

#if defined(DEBUG)
#define DBG(fmt...) udbg_printf(fmt)
#else
#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
#endif

37 38 39 40 41 42 43 44 45 46 47 48 49
/**
 * struct ps3_bmp - a per cpu irq status and mask bitmap structure
 * @status: 256 bit status bitmap indexed by plug
 * @unused_1:
 * @mask: 256 bit mask bitmap indexed by plug
 * @unused_2:
 * @lock:
 * @ipi_debug_brk_mask:
 *
 * The HV mantains per SMT thread mappings of HV outlet to HV plug on
 * behalf of the guest.  These mappings are implemented as 256 bit guest
 * supplied bitmaps indexed by plug number.  The addresses of the bitmaps
 * are registered with the HV through lv1_configure_irq_state_bitmap().
G
Geoff Levand 已提交
50 51 52
 * The HV requires that the 512 bits of status + mask not cross a page
 * boundary.  PS3_BMP_MINALIGN is used to define this minimal 64 byte
 * alignment.
53 54 55 56 57 58 59 60 61 62 63
 *
 * The HV supports 256 plugs per thread, assigned as {0..255}, for a total
 * of 512 plugs supported on a processor.  To simplify the logic this
 * implementation equates HV plug value to Linux virq value, constrains each
 * interrupt to have a system wide unique plug number, and limits the range
 * of the plug values to map into the first dword of the bitmaps.  This
 * gives a usable range of plug values of  {NUM_ISA_INTERRUPTS..63}.  Note
 * that there is no constraint on how many in this set an individual thread
 * can acquire.
 */

G
Geoff Levand 已提交
64 65
#define PS3_BMP_MINALIGN 64

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
struct ps3_bmp {
	struct {
		u64 status;
		u64 unused_1[3];
		u64 mask;
		u64 unused_2[3];
	};
	u64 ipi_debug_brk_mask;
	spinlock_t lock;
};

/**
 * struct ps3_private - a per cpu data structure
 * @bmp: ps3_bmp structure
 * @node: HV logical_ppe_id
 * @cpu: HV thread_id
 */

struct ps3_private {
G
Geoff Levand 已提交
85
	struct ps3_bmp bmp __attribute__ ((aligned (PS3_BMP_MINALIGN)));
86 87 88 89 90 91
	u64 node;
	unsigned int cpu;
};

static DEFINE_PER_CPU(struct ps3_private, ps3_private);

92 93 94 95 96 97 98 99 100 101 102 103
/**
 * ps3_virq_setup - virq related setup.
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
 * @outlet: The HV outlet from the various create outlet routines.
 * @virq: The assigned Linux virq.
 *
 * Calls irq_create_mapping() to get a virq and sets the chip data to
 * ps3_private data.
 */

int ps3_virq_setup(enum ps3_cpu_binding cpu, unsigned long outlet,
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
	unsigned int *virq)
{
	int result;
	struct ps3_private *pd;

	/* This defines the default interrupt distribution policy. */

	if (cpu == PS3_BINDING_CPU_ANY)
		cpu = 0;

	pd = &per_cpu(ps3_private, cpu);

	*virq = irq_create_mapping(NULL, outlet);

	if (*virq == NO_IRQ) {
		pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
			__func__, __LINE__, outlet);
		result = -ENOMEM;
		goto fail_create;
	}

	pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__,
		outlet, cpu, *virq);

	result = set_irq_chip_data(*virq, pd);

	if (result) {
		pr_debug("%s:%d: set_irq_chip_data failed\n",
			__func__, __LINE__);
		goto fail_set;
	}

	return result;

fail_set:
	irq_dispose_mapping(*virq);
fail_create:
	return result;
}

144 145 146 147 148 149 150 151
/**
 * ps3_virq_destroy - virq related teardown.
 * @virq: The assigned Linux virq.
 *
 * Clears chip data and calls irq_dispose_mapping() for the virq.
 */

int ps3_virq_destroy(unsigned int virq)
152 153 154 155 156 157 158 159
{
	const struct ps3_private *pd = get_irq_chip_data(virq);

	pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__,
		pd->node, pd->cpu, virq);

	set_irq_chip_data(virq, NULL);
	irq_dispose_mapping(virq);
160 161 162

	pr_debug("%s:%d <-\n", __func__, __LINE__);
	return 0;
163 164
}

165
/**
166
 * ps3_irq_plug_setup - Generic outlet and virq related setup.
167 168
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
169
 * @outlet: The HV outlet from the various create outlet routines.
170 171
 * @virq: The assigned Linux virq.
 *
172
 * Sets up virq and connects the irq plug.
173 174
 */

175
int ps3_irq_plug_setup(enum ps3_cpu_binding cpu, unsigned long outlet,
176
	unsigned int *virq)
177 178
{
	int result;
179
	struct ps3_private *pd;
180

181
	result = ps3_virq_setup(cpu, outlet, virq);
182 183

	if (result) {
184 185
		pr_debug("%s:%d: ps3_virq_setup failed\n", __func__, __LINE__);
		goto fail_setup;
186 187
	}

188 189 190 191 192
	pd = get_irq_chip_data(*virq);

	/* Binds outlet to cpu + virq. */

	result = lv1_connect_irq_plug_ext(pd->node, pd->cpu, *virq, outlet, 0);
193

194 195 196 197 198 199 200 201 202 203 204 205
	if (result) {
		pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
		__func__, __LINE__, ps3_result(result));
		result = -EPERM;
		goto fail_connect;
	}

	return result;

fail_connect:
	ps3_virq_destroy(*virq);
fail_setup:
206
	return result;
207
}
208 209 210 211 212 213 214 215 216 217
EXPORT_SYMBOL_GPL(ps3_irq_plug_setup);

/**
 * ps3_irq_plug_destroy - Generic outlet and virq related teardown.
 * @virq: The assigned Linux virq.
 *
 * Disconnects the irq plug and tears down virq.
 * Do not call for system bus event interrupts setup with
 * ps3_sb_event_receive_port_setup().
 */
218

219
int ps3_irq_plug_destroy(unsigned int virq)
220 221
{
	int result;
222
	const struct ps3_private *pd = get_irq_chip_data(virq);
223

224 225 226 227
	pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__,
		pd->node, pd->cpu, virq);

	result = lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, virq);
228

229
	if (result)
230 231
		pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
		__func__, __LINE__, ps3_result(result));
232

233
	ps3_virq_destroy(virq);
234 235 236

	return result;
}
237
EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy);
238 239

/**
240
 * ps3_event_receive_port_setup - Setup an event receive port.
241 242
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
243 244 245
 * @virq: The assigned Linux virq.
 *
 * The virq can be used with lv1_connect_interrupt_event_receive_port() to
246 247
 * arrange to receive interrupts from system-bus devices, or with
 * ps3_send_event_locally() to signal events.
248 249
 */

250
int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu, unsigned int *virq)
251 252 253 254 255 256 257 258 259 260 261 262 263
{
	int result;
	unsigned long outlet;

	result = lv1_construct_event_receive_port(&outlet);

	if (result) {
		pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
			__func__, __LINE__, ps3_result(result));
		*virq = NO_IRQ;
		return result;
	}

264
	result = ps3_irq_plug_setup(cpu, outlet, virq);
265
	BUG_ON(result);
266

267
	return result;
268
}
269 270 271 272 273 274 275 276 277 278
EXPORT_SYMBOL_GPL(ps3_event_receive_port_setup);

/**
 * ps3_event_receive_port_destroy - Destroy an event receive port.
 * @virq: The assigned Linux virq.
 *
 * Since ps3_event_receive_port_destroy destroys the receive port outlet,
 * SB devices need to call disconnect_interrupt_event_receive_port() before
 * this.
 */
279

280
int ps3_event_receive_port_destroy(unsigned int virq)
281 282 283
{
	int result;

284
	pr_debug(" -> %s:%d virq: %u\n", __func__, __LINE__, virq);
285 286 287 288 289 290 291

	result = lv1_destruct_event_receive_port(virq_to_hw(virq));

	if (result)
		pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
			__func__, __LINE__, ps3_result(result));

292 293 294 295 296 297
	/* lv1_destruct_event_receive_port() destroys the IRQ plug,
	 * so don't call ps3_irq_plug_destroy() here.
	 */

	result = ps3_virq_destroy(virq);
	BUG_ON(result);
298 299 300 301

	pr_debug(" <- %s:%d\n", __func__, __LINE__);
	return result;
}
302
EXPORT_SYMBOL_GPL(ps3_event_receive_port_destroy);
303 304 305 306 307 308 309

int ps3_send_event_locally(unsigned int virq)
{
	return lv1_send_event_locally(virq_to_hw(virq));
}

/**
310
 * ps3_sb_event_receive_port_setup - Setup a system bus event receive port.
311 312
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
313 314 315 316 317 318 319 320
 * @did: The HV device identifier read from the system repository.
 * @interrupt_id: The device interrupt id read from the system repository.
 * @virq: The assigned Linux virq.
 *
 * An event irq represents a virtual device interrupt.  The interrupt_id
 * coresponds to the software interrupt number.
 */

321
int ps3_sb_event_receive_port_setup(enum ps3_cpu_binding cpu,
322 323
	const struct ps3_device_id *did, unsigned int interrupt_id,
	unsigned int *virq)
324
{
325 326
	/* this should go in system-bus.c */

327 328
	int result;

329
	result = ps3_event_receive_port_setup(cpu, virq);
330 331 332 333 334 335 336 337 338 339 340

	if (result)
		return result;

	result = lv1_connect_interrupt_event_receive_port(did->bus_id,
		did->dev_id, virq_to_hw(*virq), interrupt_id);

	if (result) {
		pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
			" failed: %s\n", __func__, __LINE__,
			ps3_result(result));
341
		ps3_event_receive_port_destroy(*virq);
342 343 344 345 346 347 348 349 350
		*virq = NO_IRQ;
		return result;
	}

	pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
		interrupt_id, *virq);

	return 0;
}
351
EXPORT_SYMBOL(ps3_sb_event_receive_port_setup);
352

353
int ps3_sb_event_receive_port_destroy(const struct ps3_device_id *did,
354 355
	unsigned int interrupt_id, unsigned int virq)
{
356 357
	/* this should go in system-bus.c */

358 359 360 361 362 363 364 365 366 367 368 369 370
	int result;

	pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
		interrupt_id, virq);

	result = lv1_disconnect_interrupt_event_receive_port(did->bus_id,
		did->dev_id, virq_to_hw(virq), interrupt_id);

	if (result)
		pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
			" failed: %s\n", __func__, __LINE__,
			ps3_result(result));

371 372
	result = ps3_event_receive_port_destroy(virq);
	BUG_ON(result);
373 374 375 376

	pr_debug(" <- %s:%d\n", __func__, __LINE__);
	return result;
}
377
EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy);
378 379

/**
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
 * ps3_io_irq_setup - Setup a system bus io irq.
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
 * @interrupt_id: The device interrupt id read from the system repository.
 * @virq: The assigned Linux virq.
 *
 * An io irq represents a non-virtualized device interrupt.  interrupt_id
 * coresponds to the interrupt number of the interrupt controller.
 */

int ps3_io_irq_setup(enum ps3_cpu_binding cpu, unsigned int interrupt_id,
	unsigned int *virq)
{
	int result;
	unsigned long outlet;

	result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);

	if (result) {
		pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
			__func__, __LINE__, ps3_result(result));
		return result;
	}

	result = ps3_irq_plug_setup(cpu, outlet, virq);
	BUG_ON(result);

	return result;
}
EXPORT_SYMBOL_GPL(ps3_io_irq_setup);

int ps3_io_irq_destroy(unsigned int virq)
{
	int result;

	result = lv1_destruct_io_irq_outlet(virq_to_hw(virq));

	if (result)
		pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
			__func__, __LINE__, ps3_result(result));

	result = ps3_irq_plug_destroy(virq);
	BUG_ON(result);

	return result;
}
EXPORT_SYMBOL_GPL(ps3_io_irq_destroy);

/**
 * ps3_vuart_irq_setup - Setup the system virtual uart virq.
430 431
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
432 433 434 435 436 437 438
 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
 * @virq: The assigned Linux virq.
 *
 * The system supports only a single virtual uart, so multiple calls without
 * freeing the interrupt will return a wrong state error.
 */

439
int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu, void* virt_addr_bmp,
440
	unsigned int *virq)
441 442 443
{
	int result;
	unsigned long outlet;
444
	u64 lpar_addr;
445

446
	BUG_ON(!is_kernel_addr((u64)virt_addr_bmp));
447 448 449 450 451 452 453 454 455 456 457

	lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));

	result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);

	if (result) {
		pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
			__func__, __LINE__, ps3_result(result));
		return result;
	}

458
	result = ps3_irq_plug_setup(cpu, outlet, virq);
459
	BUG_ON(result);
460

461
	return result;
462 463
}

464
int ps3_vuart_irq_destroy(unsigned int virq)
465 466 467 468 469 470 471 472 473 474 475
{
	int result;

	result = lv1_deconfigure_virtual_uart_irq();

	if (result) {
		pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
			__func__, __LINE__, ps3_result(result));
		return result;
	}

476 477
	result = ps3_irq_plug_destroy(virq);
	BUG_ON(result);
478 479 480 481 482

	return result;
}

/**
483
 * ps3_spe_irq_setup - Setup an spe virq.
484 485
 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 * serviced on.
486 487 488 489 490 491
 * @spe_id: The spe_id returned from lv1_construct_logical_spe().
 * @class: The spe interrupt class {0,1,2}.
 * @virq: The assigned Linux virq.
 *
 */

492
int ps3_spe_irq_setup(enum ps3_cpu_binding cpu, unsigned long spe_id,
493
	unsigned int class, unsigned int *virq)
494 495 496 497 498 499 500 501 502 503 504 505 506 507
{
	int result;
	unsigned long outlet;

	BUG_ON(class > 2);

	result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);

	if (result) {
		pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
			__func__, __LINE__, ps3_result(result));
		return result;
	}

508
	result = ps3_irq_plug_setup(cpu, outlet, virq);
509
	BUG_ON(result);
510

511
	return result;
512 513
}

514
int ps3_spe_irq_destroy(unsigned int virq)
515
{
516 517
	int result = ps3_irq_plug_destroy(virq);
	BUG_ON(result);
518 519 520
	return 0;
}

521

522 523 524 525
#define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
#define PS3_PLUG_MAX 63

#if defined(DEBUG)
526
static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu,
527 528 529 530 531 532 533 534 535
	const char* func, int line)
{
	pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
		func, line, header, cpu,
		*p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
		*p & 0xffff);
}

static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
536
	const u64 *p, unsigned cpu, const char* func, int line)
537 538 539 540 541 542
{
	pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
		func, line, header, cpu, p[0], p[1], p[2], p[3]);
}

#define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
543
static void _dump_bmp(struct ps3_private* pd, const char* func, int line)
544 545 546 547 548 549 550 551 552 553
{
	unsigned long flags;

	spin_lock_irqsave(&pd->bmp.lock, flags);
	_dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
	_dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
	spin_unlock_irqrestore(&pd->bmp.lock, flags);
}

#define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
554
static void __attribute__ ((unused)) _dump_mask(struct ps3_private* pd,
555 556 557 558 559 560 561 562 563
	const char* func, int line)
{
	unsigned long flags;

	spin_lock_irqsave(&pd->bmp.lock, flags);
	_dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
	spin_unlock_irqrestore(&pd->bmp.lock, flags);
}
#else
564
static void dump_bmp(struct ps3_private* pd) {};
565 566
#endif /* defined(DEBUG) */

567
static void ps3_chip_mask(unsigned int virq)
568
{
569
	struct ps3_private *pd = get_irq_chip_data(virq);
570 571 572
	u64 bit = 0x8000000000000000UL >> virq;
	u64 *p = &pd->bmp.mask;
	u64 old;
573
	unsigned long flags;
574 575 576

	pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);

577 578 579 580 581 582 583 584 585
	local_irq_save(flags);
	asm volatile(
		     "1:	ldarx %0,0,%3\n"
		     "andc	%0,%0,%2\n"
		     "stdcx.	%0,0,%3\n"
		     "bne-	1b"
		     : "=&r" (old), "+m" (*p)
		     : "r" (bit), "r" (p)
		     : "cc" );
586 587

	lv1_did_update_interrupt_mask(pd->node, pd->cpu);
588
	local_irq_restore(flags);
589 590
}

591
static void ps3_chip_unmask(unsigned int virq)
592
{
593
	struct ps3_private *pd = get_irq_chip_data(virq);
594 595 596
	u64 bit = 0x8000000000000000UL >> virq;
	u64 *p = &pd->bmp.mask;
	u64 old;
597
	unsigned long flags;
598 599 600

	pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);

601 602 603 604 605 606 607 608 609
	local_irq_save(flags);
	asm volatile(
		     "1:	ldarx %0,0,%3\n"
		     "or	%0,%0,%2\n"
		     "stdcx.	%0,0,%3\n"
		     "bne-	1b"
		     : "=&r" (old), "+m" (*p)
		     : "r" (bit), "r" (p)
		     : "cc" );
610 611

	lv1_did_update_interrupt_mask(pd->node, pd->cpu);
612
	local_irq_restore(flags);
613 614
}

615
static void ps3_chip_eoi(unsigned int virq)
616
{
617 618
	const struct ps3_private *pd = get_irq_chip_data(virq);
	lv1_end_of_interrupt_ext(pd->node, pd->cpu, virq);
619 620 621 622
}

static struct irq_chip irq_chip = {
	.typename = "ps3",
623 624 625
	.mask = ps3_chip_mask,
	.unmask = ps3_chip_unmask,
	.eoi = ps3_chip_eoi,
626 627
};

628
static void ps3_host_unmap(struct irq_host *h, unsigned int virq)
629
{
630
	set_irq_chip_data(virq, NULL);
631 632
}

633
static int ps3_host_map(struct irq_host *h, unsigned int virq,
634 635
	irq_hw_number_t hwirq)
{
636 637
	pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq,
		virq);
638 639 640

	set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);

641
	return 0;
642 643
}

644 645 646
static struct irq_host_ops ps3_host_ops = {
	.map = ps3_host_map,
	.unmap = ps3_host_unmap,
647 648 649 650
};

void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
{
651
	struct ps3_private *pd = &per_cpu(ps3_private, cpu);
652 653 654 655 656 657 658

	pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;

	pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
		cpu, virq, pd->bmp.ipi_debug_brk_mask);
}

659
unsigned int ps3_get_irq(void)
660
{
661
	struct ps3_private *pd = &__get_cpu_var(ps3_private);
662
	u64 x = (pd->bmp.status & pd->bmp.mask);
663
	unsigned int plug;
664 665 666

	/* check for ipi break first to stop this cpu ASAP */

667 668
	if (x & pd->bmp.ipi_debug_brk_mask)
		x &= pd->bmp.ipi_debug_brk_mask;
669

670 671
	asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x));
	plug &= 0x3f;
672

673
	if (unlikely(plug) == NO_IRQ) {
674 675
		pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
			pd->cpu);
676 677
		dump_bmp(&per_cpu(ps3_private, 0));
		dump_bmp(&per_cpu(ps3_private, 1));
678 679 680 681
		return NO_IRQ;
	}

#if defined(DEBUG)
682
	if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) {
683 684
		dump_bmp(&per_cpu(ps3_private, 0));
		dump_bmp(&per_cpu(ps3_private, 1));
685 686 687 688 689 690 691 692 693 694 695 696
		BUG();
	}
#endif
	return plug;
}

void __init ps3_init_IRQ(void)
{
	int result;
	unsigned cpu;
	struct irq_host *host;

697
	host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops,
698 699 700 701 702
		PS3_INVALID_OUTLET);
	irq_set_default_host(host);
	irq_set_virq_count(PS3_PLUG_MAX + 1);

	for_each_possible_cpu(cpu) {
703
		struct ps3_private *pd = &per_cpu(ps3_private, cpu);
704

705 706
		lv1_get_logical_ppe_id(&pd->node);
		pd->cpu = get_hard_smp_processor_id(cpu);
707 708
		spin_lock_init(&pd->bmp.lock);

709 710 711 712 713 714
		pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__,
			__LINE__, pd->node, pd->cpu,
			ps3_mm_phys_to_lpar(__pa(&pd->bmp)));

		result = lv1_configure_irq_state_bitmap(pd->node, pd->cpu,
			ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
715 716 717 718 719 720 721 722 723

		if (result)
			pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
				" %s\n", __func__, __LINE__,
				ps3_result(result));
	}

	ppc_md.get_irq = ps3_get_irq;
}