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