1 /* 2 * PS3 interrupt routines. 3 * 4 * Copyright (C) 2006 Sony Computer Entertainment Inc. 5 * Copyright 2006 Sony Corp. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; version 2 of the License. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/irq.h> 24 25 #include <asm/machdep.h> 26 #include <asm/udbg.h> 27 #include <asm/lv1call.h> 28 #include <asm/smp.h> 29 30 #include "platform.h" 31 32 #if defined(DEBUG) 33 #define DBG udbg_printf 34 #else 35 #define DBG pr_debug 36 #endif 37 38 /** 39 * struct ps3_bmp - a per cpu irq status and mask bitmap structure 40 * @status: 256 bit status bitmap indexed by plug 41 * @unused_1: 42 * @mask: 256 bit mask bitmap indexed by plug 43 * @unused_2: 44 * @lock: 45 * @ipi_debug_brk_mask: 46 * 47 * The HV mantains per SMT thread mappings of HV outlet to HV plug on 48 * behalf of the guest. These mappings are implemented as 256 bit guest 49 * supplied bitmaps indexed by plug number. The addresses of the bitmaps 50 * are registered with the HV through lv1_configure_irq_state_bitmap(). 51 * The HV requires that the 512 bits of status + mask not cross a page 52 * boundary. PS3_BMP_MINALIGN is used to define this minimal 64 byte 53 * alignment. 54 * 55 * The HV supports 256 plugs per thread, assigned as {0..255}, for a total 56 * of 512 plugs supported on a processor. To simplify the logic this 57 * implementation equates HV plug value to Linux virq value, constrains each 58 * interrupt to have a system wide unique plug number, and limits the range 59 * of the plug values to map into the first dword of the bitmaps. This 60 * gives a usable range of plug values of {NUM_ISA_INTERRUPTS..63}. Note 61 * that there is no constraint on how many in this set an individual thread 62 * can acquire. 63 */ 64 65 #define PS3_BMP_MINALIGN 64 66 67 struct ps3_bmp { 68 struct { 69 u64 status; 70 u64 unused_1[3]; 71 u64 mask; 72 u64 unused_2[3]; 73 }; 74 u64 ipi_debug_brk_mask; 75 spinlock_t lock; 76 }; 77 78 /** 79 * struct ps3_private - a per cpu data structure 80 * @bmp: ps3_bmp structure 81 * @ppe_id: HV logical_ppe_id 82 * @thread_id: HV thread_id 83 */ 84 85 struct ps3_private { 86 struct ps3_bmp bmp __attribute__ ((aligned (PS3_BMP_MINALIGN))); 87 u64 ppe_id; 88 u64 thread_id; 89 }; 90 91 static DEFINE_PER_CPU(struct ps3_private, ps3_private); 92 93 /** 94 * ps3_chip_mask - Set an interrupt mask bit in ps3_bmp. 95 * @virq: The assigned Linux virq. 96 * 97 * Sets ps3_bmp.mask and calls lv1_did_update_interrupt_mask(). 98 */ 99 100 static void ps3_chip_mask(unsigned int virq) 101 { 102 struct ps3_private *pd = get_irq_chip_data(virq); 103 unsigned long flags; 104 105 pr_debug("%s:%d: thread_id %lu, virq %d\n", __func__, __LINE__, 106 pd->thread_id, virq); 107 108 local_irq_save(flags); 109 clear_bit(63 - virq, &pd->bmp.mask); 110 lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id); 111 local_irq_restore(flags); 112 } 113 114 /** 115 * ps3_chip_unmask - Clear an interrupt mask bit in ps3_bmp. 116 * @virq: The assigned Linux virq. 117 * 118 * Clears ps3_bmp.mask and calls lv1_did_update_interrupt_mask(). 119 */ 120 121 static void ps3_chip_unmask(unsigned int virq) 122 { 123 struct ps3_private *pd = get_irq_chip_data(virq); 124 unsigned long flags; 125 126 pr_debug("%s:%d: thread_id %lu, virq %d\n", __func__, __LINE__, 127 pd->thread_id, virq); 128 129 local_irq_save(flags); 130 set_bit(63 - virq, &pd->bmp.mask); 131 lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id); 132 local_irq_restore(flags); 133 } 134 135 /** 136 * ps3_chip_eoi - HV end-of-interrupt. 137 * @virq: The assigned Linux virq. 138 * 139 * Calls lv1_end_of_interrupt_ext(). 140 */ 141 142 static void ps3_chip_eoi(unsigned int virq) 143 { 144 const struct ps3_private *pd = get_irq_chip_data(virq); 145 lv1_end_of_interrupt_ext(pd->ppe_id, pd->thread_id, virq); 146 } 147 148 /** 149 * ps3_irq_chip - Represents the ps3_bmp as a Linux struct irq_chip. 150 */ 151 152 static struct irq_chip ps3_irq_chip = { 153 .typename = "ps3", 154 .mask = ps3_chip_mask, 155 .unmask = ps3_chip_unmask, 156 .eoi = ps3_chip_eoi, 157 }; 158 159 /** 160 * ps3_virq_setup - virq related setup. 161 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 162 * serviced on. 163 * @outlet: The HV outlet from the various create outlet routines. 164 * @virq: The assigned Linux virq. 165 * 166 * Calls irq_create_mapping() to get a virq and sets the chip data to 167 * ps3_private data. 168 */ 169 170 int ps3_virq_setup(enum ps3_cpu_binding cpu, unsigned long outlet, 171 unsigned int *virq) 172 { 173 int result; 174 struct ps3_private *pd; 175 176 /* This defines the default interrupt distribution policy. */ 177 178 if (cpu == PS3_BINDING_CPU_ANY) 179 cpu = 0; 180 181 pd = &per_cpu(ps3_private, cpu); 182 183 *virq = irq_create_mapping(NULL, outlet); 184 185 if (*virq == NO_IRQ) { 186 pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n", 187 __func__, __LINE__, outlet); 188 result = -ENOMEM; 189 goto fail_create; 190 } 191 192 pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__, 193 outlet, cpu, *virq); 194 195 result = set_irq_chip_data(*virq, pd); 196 197 if (result) { 198 pr_debug("%s:%d: set_irq_chip_data failed\n", 199 __func__, __LINE__); 200 goto fail_set; 201 } 202 203 ps3_chip_mask(*virq); 204 205 return result; 206 207 fail_set: 208 irq_dispose_mapping(*virq); 209 fail_create: 210 return result; 211 } 212 213 /** 214 * ps3_virq_destroy - virq related teardown. 215 * @virq: The assigned Linux virq. 216 * 217 * Clears chip data and calls irq_dispose_mapping() for the virq. 218 */ 219 220 int ps3_virq_destroy(unsigned int virq) 221 { 222 const struct ps3_private *pd = get_irq_chip_data(virq); 223 224 pr_debug("%s:%d: ppe_id %lu, thread_id %lu, virq %u\n", __func__, 225 __LINE__, pd->ppe_id, pd->thread_id, virq); 226 227 set_irq_chip_data(virq, NULL); 228 irq_dispose_mapping(virq); 229 230 pr_debug("%s:%d <-\n", __func__, __LINE__); 231 return 0; 232 } 233 234 /** 235 * ps3_irq_plug_setup - Generic outlet and virq related setup. 236 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 237 * serviced on. 238 * @outlet: The HV outlet from the various create outlet routines. 239 * @virq: The assigned Linux virq. 240 * 241 * Sets up virq and connects the irq plug. 242 */ 243 244 int ps3_irq_plug_setup(enum ps3_cpu_binding cpu, unsigned long outlet, 245 unsigned int *virq) 246 { 247 int result; 248 struct ps3_private *pd; 249 250 result = ps3_virq_setup(cpu, outlet, virq); 251 252 if (result) { 253 pr_debug("%s:%d: ps3_virq_setup failed\n", __func__, __LINE__); 254 goto fail_setup; 255 } 256 257 pd = get_irq_chip_data(*virq); 258 259 /* Binds outlet to cpu + virq. */ 260 261 result = lv1_connect_irq_plug_ext(pd->ppe_id, pd->thread_id, *virq, 262 outlet, 0); 263 264 if (result) { 265 pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n", 266 __func__, __LINE__, ps3_result(result)); 267 result = -EPERM; 268 goto fail_connect; 269 } 270 271 return result; 272 273 fail_connect: 274 ps3_virq_destroy(*virq); 275 fail_setup: 276 return result; 277 } 278 EXPORT_SYMBOL_GPL(ps3_irq_plug_setup); 279 280 /** 281 * ps3_irq_plug_destroy - Generic outlet and virq related teardown. 282 * @virq: The assigned Linux virq. 283 * 284 * Disconnects the irq plug and tears down virq. 285 * Do not call for system bus event interrupts setup with 286 * ps3_sb_event_receive_port_setup(). 287 */ 288 289 int ps3_irq_plug_destroy(unsigned int virq) 290 { 291 int result; 292 const struct ps3_private *pd = get_irq_chip_data(virq); 293 294 pr_debug("%s:%d: ppe_id %lu, thread_id %lu, virq %u\n", __func__, 295 __LINE__, pd->ppe_id, pd->thread_id, virq); 296 297 ps3_chip_mask(virq); 298 299 result = lv1_disconnect_irq_plug_ext(pd->ppe_id, pd->thread_id, virq); 300 301 if (result) 302 pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n", 303 __func__, __LINE__, ps3_result(result)); 304 305 ps3_virq_destroy(virq); 306 307 return result; 308 } 309 EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy); 310 311 /** 312 * ps3_event_receive_port_setup - Setup an event receive port. 313 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 314 * serviced on. 315 * @virq: The assigned Linux virq. 316 * 317 * The virq can be used with lv1_connect_interrupt_event_receive_port() to 318 * arrange to receive interrupts from system-bus devices, or with 319 * ps3_send_event_locally() to signal events. 320 */ 321 322 int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu, unsigned int *virq) 323 { 324 int result; 325 unsigned long outlet; 326 327 result = lv1_construct_event_receive_port(&outlet); 328 329 if (result) { 330 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n", 331 __func__, __LINE__, ps3_result(result)); 332 *virq = NO_IRQ; 333 return result; 334 } 335 336 result = ps3_irq_plug_setup(cpu, outlet, virq); 337 BUG_ON(result); 338 339 return result; 340 } 341 EXPORT_SYMBOL_GPL(ps3_event_receive_port_setup); 342 343 /** 344 * ps3_event_receive_port_destroy - Destroy an event receive port. 345 * @virq: The assigned Linux virq. 346 * 347 * Since ps3_event_receive_port_destroy destroys the receive port outlet, 348 * SB devices need to call disconnect_interrupt_event_receive_port() before 349 * this. 350 */ 351 352 int ps3_event_receive_port_destroy(unsigned int virq) 353 { 354 int result; 355 356 pr_debug(" -> %s:%d virq %u\n", __func__, __LINE__, virq); 357 358 ps3_chip_mask(virq); 359 360 result = lv1_destruct_event_receive_port(virq_to_hw(virq)); 361 362 if (result) 363 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n", 364 __func__, __LINE__, ps3_result(result)); 365 366 /* 367 * Don't call ps3_virq_destroy() here since ps3_smp_cleanup_cpu() 368 * calls from interrupt context (smp_call_function) when kexecing. 369 */ 370 371 pr_debug(" <- %s:%d\n", __func__, __LINE__); 372 return result; 373 } 374 375 int ps3_send_event_locally(unsigned int virq) 376 { 377 return lv1_send_event_locally(virq_to_hw(virq)); 378 } 379 380 /** 381 * ps3_sb_event_receive_port_setup - Setup a system bus event receive port. 382 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 383 * serviced on. 384 * @dev: The system bus device instance. 385 * @virq: The assigned Linux virq. 386 * 387 * An event irq represents a virtual device interrupt. The interrupt_id 388 * coresponds to the software interrupt number. 389 */ 390 391 int ps3_sb_event_receive_port_setup(struct ps3_system_bus_device *dev, 392 enum ps3_cpu_binding cpu, unsigned int *virq) 393 { 394 /* this should go in system-bus.c */ 395 396 int result; 397 398 result = ps3_event_receive_port_setup(cpu, virq); 399 400 if (result) 401 return result; 402 403 result = lv1_connect_interrupt_event_receive_port(dev->bus_id, 404 dev->dev_id, virq_to_hw(*virq), dev->interrupt_id); 405 406 if (result) { 407 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port" 408 " failed: %s\n", __func__, __LINE__, 409 ps3_result(result)); 410 ps3_event_receive_port_destroy(*virq); 411 *virq = NO_IRQ; 412 return result; 413 } 414 415 pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__, 416 dev->interrupt_id, *virq); 417 418 return 0; 419 } 420 EXPORT_SYMBOL(ps3_sb_event_receive_port_setup); 421 422 int ps3_sb_event_receive_port_destroy(struct ps3_system_bus_device *dev, 423 unsigned int virq) 424 { 425 /* this should go in system-bus.c */ 426 427 int result; 428 429 pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__, 430 dev->interrupt_id, virq); 431 432 result = lv1_disconnect_interrupt_event_receive_port(dev->bus_id, 433 dev->dev_id, virq_to_hw(virq), dev->interrupt_id); 434 435 if (result) 436 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port" 437 " failed: %s\n", __func__, __LINE__, 438 ps3_result(result)); 439 440 result = ps3_event_receive_port_destroy(virq); 441 BUG_ON(result); 442 443 /* 444 * ps3_event_receive_port_destroy() destroys the IRQ plug, 445 * so don't call ps3_irq_plug_destroy() here. 446 */ 447 448 result = ps3_virq_destroy(virq); 449 BUG_ON(result); 450 451 pr_debug(" <- %s:%d\n", __func__, __LINE__); 452 return result; 453 } 454 EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy); 455 456 /** 457 * ps3_io_irq_setup - Setup a system bus io irq. 458 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 459 * serviced on. 460 * @interrupt_id: The device interrupt id read from the system repository. 461 * @virq: The assigned Linux virq. 462 * 463 * An io irq represents a non-virtualized device interrupt. interrupt_id 464 * coresponds to the interrupt number of the interrupt controller. 465 */ 466 467 int ps3_io_irq_setup(enum ps3_cpu_binding cpu, unsigned int interrupt_id, 468 unsigned int *virq) 469 { 470 int result; 471 unsigned long outlet; 472 473 result = lv1_construct_io_irq_outlet(interrupt_id, &outlet); 474 475 if (result) { 476 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n", 477 __func__, __LINE__, ps3_result(result)); 478 return result; 479 } 480 481 result = ps3_irq_plug_setup(cpu, outlet, virq); 482 BUG_ON(result); 483 484 return result; 485 } 486 EXPORT_SYMBOL_GPL(ps3_io_irq_setup); 487 488 int ps3_io_irq_destroy(unsigned int virq) 489 { 490 int result; 491 unsigned long outlet = virq_to_hw(virq); 492 493 ps3_chip_mask(virq); 494 495 /* 496 * lv1_destruct_io_irq_outlet() will destroy the IRQ plug, 497 * so call ps3_irq_plug_destroy() first. 498 */ 499 500 result = ps3_irq_plug_destroy(virq); 501 BUG_ON(result); 502 503 result = lv1_destruct_io_irq_outlet(outlet); 504 505 if (result) 506 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n", 507 __func__, __LINE__, ps3_result(result)); 508 509 return result; 510 } 511 EXPORT_SYMBOL_GPL(ps3_io_irq_destroy); 512 513 /** 514 * ps3_vuart_irq_setup - Setup the system virtual uart virq. 515 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 516 * serviced on. 517 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap. 518 * @virq: The assigned Linux virq. 519 * 520 * The system supports only a single virtual uart, so multiple calls without 521 * freeing the interrupt will return a wrong state error. 522 */ 523 524 int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu, void* virt_addr_bmp, 525 unsigned int *virq) 526 { 527 int result; 528 unsigned long outlet; 529 u64 lpar_addr; 530 531 BUG_ON(!is_kernel_addr((u64)virt_addr_bmp)); 532 533 lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp)); 534 535 result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet); 536 537 if (result) { 538 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n", 539 __func__, __LINE__, ps3_result(result)); 540 return result; 541 } 542 543 result = ps3_irq_plug_setup(cpu, outlet, virq); 544 BUG_ON(result); 545 546 return result; 547 } 548 EXPORT_SYMBOL_GPL(ps3_vuart_irq_setup); 549 550 int ps3_vuart_irq_destroy(unsigned int virq) 551 { 552 int result; 553 554 ps3_chip_mask(virq); 555 result = lv1_deconfigure_virtual_uart_irq(); 556 557 if (result) { 558 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n", 559 __func__, __LINE__, ps3_result(result)); 560 return result; 561 } 562 563 result = ps3_irq_plug_destroy(virq); 564 BUG_ON(result); 565 566 return result; 567 } 568 EXPORT_SYMBOL_GPL(ps3_vuart_irq_destroy); 569 570 /** 571 * ps3_spe_irq_setup - Setup an spe virq. 572 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be 573 * serviced on. 574 * @spe_id: The spe_id returned from lv1_construct_logical_spe(). 575 * @class: The spe interrupt class {0,1,2}. 576 * @virq: The assigned Linux virq. 577 * 578 */ 579 580 int ps3_spe_irq_setup(enum ps3_cpu_binding cpu, unsigned long spe_id, 581 unsigned int class, unsigned int *virq) 582 { 583 int result; 584 unsigned long outlet; 585 586 BUG_ON(class > 2); 587 588 result = lv1_get_spe_irq_outlet(spe_id, class, &outlet); 589 590 if (result) { 591 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n", 592 __func__, __LINE__, ps3_result(result)); 593 return result; 594 } 595 596 result = ps3_irq_plug_setup(cpu, outlet, virq); 597 BUG_ON(result); 598 599 return result; 600 } 601 602 int ps3_spe_irq_destroy(unsigned int virq) 603 { 604 int result; 605 606 ps3_chip_mask(virq); 607 608 result = ps3_irq_plug_destroy(virq); 609 BUG_ON(result); 610 611 return result; 612 } 613 614 615 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1) 616 #define PS3_PLUG_MAX 63 617 618 #if defined(DEBUG) 619 static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu, 620 const char* func, int line) 621 { 622 pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n", 623 func, line, header, cpu, 624 *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff, 625 *p & 0xffff); 626 } 627 628 static void __maybe_unused _dump_256_bmp(const char *header, 629 const u64 *p, unsigned cpu, const char* func, int line) 630 { 631 pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n", 632 func, line, header, cpu, p[0], p[1], p[2], p[3]); 633 } 634 635 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__) 636 static void _dump_bmp(struct ps3_private* pd, const char* func, int line) 637 { 638 unsigned long flags; 639 640 spin_lock_irqsave(&pd->bmp.lock, flags); 641 _dump_64_bmp("stat", &pd->bmp.status, pd->thread_id, func, line); 642 _dump_64_bmp("mask", &pd->bmp.mask, pd->thread_id, func, line); 643 spin_unlock_irqrestore(&pd->bmp.lock, flags); 644 } 645 646 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__) 647 static void __maybe_unused _dump_mask(struct ps3_private *pd, 648 const char* func, int line) 649 { 650 unsigned long flags; 651 652 spin_lock_irqsave(&pd->bmp.lock, flags); 653 _dump_64_bmp("mask", &pd->bmp.mask, pd->thread_id, func, line); 654 spin_unlock_irqrestore(&pd->bmp.lock, flags); 655 } 656 #else 657 static void dump_bmp(struct ps3_private* pd) {}; 658 #endif /* defined(DEBUG) */ 659 660 static void ps3_host_unmap(struct irq_host *h, unsigned int virq) 661 { 662 set_irq_chip_data(virq, NULL); 663 } 664 665 static int ps3_host_map(struct irq_host *h, unsigned int virq, 666 irq_hw_number_t hwirq) 667 { 668 pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq, 669 virq); 670 671 set_irq_chip_and_handler(virq, &ps3_irq_chip, handle_fasteoi_irq); 672 673 return 0; 674 } 675 676 static int ps3_host_match(struct irq_host *h, struct device_node *np) 677 { 678 /* Match all */ 679 return 1; 680 } 681 682 static struct irq_host_ops ps3_host_ops = { 683 .map = ps3_host_map, 684 .unmap = ps3_host_unmap, 685 .match = ps3_host_match, 686 }; 687 688 void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq) 689 { 690 struct ps3_private *pd = &per_cpu(ps3_private, cpu); 691 692 pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq; 693 694 pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__, 695 cpu, virq, pd->bmp.ipi_debug_brk_mask); 696 } 697 698 static unsigned int ps3_get_irq(void) 699 { 700 struct ps3_private *pd = &__get_cpu_var(ps3_private); 701 u64 x = (pd->bmp.status & pd->bmp.mask); 702 unsigned int plug; 703 704 /* check for ipi break first to stop this cpu ASAP */ 705 706 if (x & pd->bmp.ipi_debug_brk_mask) 707 x &= pd->bmp.ipi_debug_brk_mask; 708 709 asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x)); 710 plug &= 0x3f; 711 712 if (unlikely(plug) == NO_IRQ) { 713 pr_debug("%s:%d: no plug found: thread_id %lu\n", __func__, 714 __LINE__, pd->thread_id); 715 dump_bmp(&per_cpu(ps3_private, 0)); 716 dump_bmp(&per_cpu(ps3_private, 1)); 717 return NO_IRQ; 718 } 719 720 #if defined(DEBUG) 721 if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) { 722 dump_bmp(&per_cpu(ps3_private, 0)); 723 dump_bmp(&per_cpu(ps3_private, 1)); 724 BUG(); 725 } 726 #endif 727 return plug; 728 } 729 730 void __init ps3_init_IRQ(void) 731 { 732 int result; 733 unsigned cpu; 734 struct irq_host *host; 735 736 host = irq_alloc_host(NULL, IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops, 737 PS3_INVALID_OUTLET); 738 irq_set_default_host(host); 739 irq_set_virq_count(PS3_PLUG_MAX + 1); 740 741 for_each_possible_cpu(cpu) { 742 struct ps3_private *pd = &per_cpu(ps3_private, cpu); 743 744 lv1_get_logical_ppe_id(&pd->ppe_id); 745 pd->thread_id = get_hard_smp_processor_id(cpu); 746 spin_lock_init(&pd->bmp.lock); 747 748 pr_debug("%s:%d: ppe_id %lu, thread_id %lu, bmp %lxh\n", 749 __func__, __LINE__, pd->ppe_id, pd->thread_id, 750 ps3_mm_phys_to_lpar(__pa(&pd->bmp))); 751 752 result = lv1_configure_irq_state_bitmap(pd->ppe_id, 753 pd->thread_id, ps3_mm_phys_to_lpar(__pa(&pd->bmp))); 754 755 if (result) 756 pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:" 757 " %s\n", __func__, __LINE__, 758 ps3_result(result)); 759 } 760 761 ppc_md.get_irq = ps3_get_irq; 762 } 763 764 void ps3_shutdown_IRQ(int cpu) 765 { 766 int result; 767 u64 ppe_id; 768 u64 thread_id = get_hard_smp_processor_id(cpu); 769 770 lv1_get_logical_ppe_id(&ppe_id); 771 result = lv1_configure_irq_state_bitmap(ppe_id, thread_id, 0); 772 773 DBG("%s:%d: lv1_configure_irq_state_bitmap (%lu:%lu/%d) %s\n", __func__, 774 __LINE__, ppe_id, thread_id, cpu, ps3_result(result)); 775 } 776