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