2 * PS3 interrupt routines.
4 * Copyright (C) 2006 Sony Computer Entertainment Inc.
5 * Copyright 2006 Sony Corp.
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.
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.
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
21 #include <linux/kernel.h>
22 #include <linux/export.h>
23 #include <linux/irq.h>
25 #include <asm/machdep.h>
27 #include <asm/lv1call.h>
33 #define DBG udbg_printf
34 #define FAIL udbg_printf
41 * struct ps3_bmp - a per cpu irq status and mask bitmap structure
42 * @status: 256 bit status bitmap indexed by plug
43 * @unused_1: Alignment
44 * @mask: 256 bit mask bitmap indexed by plug
45 * @unused_2: Alignment
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
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
64 * The mask is declared as unsigned long so we can use set/clear_bit on it.
67 #define PS3_BMP_MINALIGN 64
79 * struct ps3_private - a per cpu data structure
80 * @bmp: ps3_bmp structure
81 * @bmp_lock: Syncronize access to bmp.
82 * @ipi_debug_brk_mask: Mask for debug break IPIs
83 * @ppe_id: HV logical_ppe_id
84 * @thread_id: HV thread_id
85 * @ipi_mask: Mask of IPI virqs
89 struct ps3_bmp bmp __attribute__ ((aligned (PS3_BMP_MINALIGN)));
93 unsigned long ipi_debug_brk_mask;
94 unsigned long ipi_mask;
97 static DEFINE_PER_CPU(struct ps3_private, ps3_private);
100 * ps3_chip_mask - Set an interrupt mask bit in ps3_bmp.
101 * @virq: The assigned Linux virq.
103 * Sets ps3_bmp.mask and calls lv1_did_update_interrupt_mask().
106 static void ps3_chip_mask(struct irq_data *d)
108 struct ps3_private *pd = irq_data_get_irq_chip_data(d);
111 DBG("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__,
112 pd->thread_id, d->irq);
114 local_irq_save(flags);
115 clear_bit(63 - d->irq, &pd->bmp.mask);
116 lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id);
117 local_irq_restore(flags);
121 * ps3_chip_unmask - Clear an interrupt mask bit in ps3_bmp.
122 * @virq: The assigned Linux virq.
124 * Clears ps3_bmp.mask and calls lv1_did_update_interrupt_mask().
127 static void ps3_chip_unmask(struct irq_data *d)
129 struct ps3_private *pd = irq_data_get_irq_chip_data(d);
132 DBG("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__,
133 pd->thread_id, d->irq);
135 local_irq_save(flags);
136 set_bit(63 - d->irq, &pd->bmp.mask);
137 lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id);
138 local_irq_restore(flags);
142 * ps3_chip_eoi - HV end-of-interrupt.
143 * @virq: The assigned Linux virq.
145 * Calls lv1_end_of_interrupt_ext().
148 static void ps3_chip_eoi(struct irq_data *d)
150 const struct ps3_private *pd = irq_data_get_irq_chip_data(d);
152 /* non-IPIs are EOIed here. */
154 if (!test_bit(63 - d->irq, &pd->ipi_mask))
155 lv1_end_of_interrupt_ext(pd->ppe_id, pd->thread_id, d->irq);
159 * ps3_irq_chip - Represents the ps3_bmp as a Linux struct irq_chip.
162 static struct irq_chip ps3_irq_chip = {
164 .irq_mask = ps3_chip_mask,
165 .irq_unmask = ps3_chip_unmask,
166 .irq_eoi = ps3_chip_eoi,
170 * ps3_virq_setup - virq related setup.
171 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
173 * @outlet: The HV outlet from the various create outlet routines.
174 * @virq: The assigned Linux virq.
176 * Calls irq_create_mapping() to get a virq and sets the chip data to
180 static int ps3_virq_setup(enum ps3_cpu_binding cpu, unsigned long outlet,
184 struct ps3_private *pd;
186 /* This defines the default interrupt distribution policy. */
188 if (cpu == PS3_BINDING_CPU_ANY)
191 pd = &per_cpu(ps3_private, cpu);
193 *virq = irq_create_mapping(NULL, outlet);
195 if (*virq == NO_IRQ) {
196 FAIL("%s:%d: irq_create_mapping failed: outlet %lu\n",
197 __func__, __LINE__, outlet);
202 DBG("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__,
205 result = irq_set_chip_data(*virq, pd);
208 FAIL("%s:%d: irq_set_chip_data failed\n",
213 ps3_chip_mask(irq_get_irq_data(*virq));
218 irq_dispose_mapping(*virq);
224 * ps3_virq_destroy - virq related teardown.
225 * @virq: The assigned Linux virq.
227 * Clears chip data and calls irq_dispose_mapping() for the virq.
230 static int ps3_virq_destroy(unsigned int virq)
232 const struct ps3_private *pd = irq_get_chip_data(virq);
234 DBG("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__,
235 __LINE__, pd->ppe_id, pd->thread_id, virq);
237 irq_set_chip_data(virq, NULL);
238 irq_dispose_mapping(virq);
240 DBG("%s:%d <-\n", __func__, __LINE__);
245 * ps3_irq_plug_setup - Generic outlet and virq related setup.
246 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
248 * @outlet: The HV outlet from the various create outlet routines.
249 * @virq: The assigned Linux virq.
251 * Sets up virq and connects the irq plug.
254 int ps3_irq_plug_setup(enum ps3_cpu_binding cpu, unsigned long outlet,
258 struct ps3_private *pd;
260 result = ps3_virq_setup(cpu, outlet, virq);
263 FAIL("%s:%d: ps3_virq_setup failed\n", __func__, __LINE__);
267 pd = irq_get_chip_data(*virq);
269 /* Binds outlet to cpu + virq. */
271 result = lv1_connect_irq_plug_ext(pd->ppe_id, pd->thread_id, *virq,
275 FAIL("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
276 __func__, __LINE__, ps3_result(result));
284 ps3_virq_destroy(*virq);
288 EXPORT_SYMBOL_GPL(ps3_irq_plug_setup);
291 * ps3_irq_plug_destroy - Generic outlet and virq related teardown.
292 * @virq: The assigned Linux virq.
294 * Disconnects the irq plug and tears down virq.
295 * Do not call for system bus event interrupts setup with
296 * ps3_sb_event_receive_port_setup().
299 int ps3_irq_plug_destroy(unsigned int virq)
302 const struct ps3_private *pd = irq_get_chip_data(virq);
304 DBG("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__,
305 __LINE__, pd->ppe_id, pd->thread_id, virq);
307 ps3_chip_mask(irq_get_irq_data(virq));
309 result = lv1_disconnect_irq_plug_ext(pd->ppe_id, pd->thread_id, virq);
312 FAIL("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
313 __func__, __LINE__, ps3_result(result));
315 ps3_virq_destroy(virq);
319 EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy);
322 * ps3_event_receive_port_setup - Setup an event receive port.
323 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
325 * @virq: The assigned Linux virq.
327 * The virq can be used with lv1_connect_interrupt_event_receive_port() to
328 * arrange to receive interrupts from system-bus devices, or with
329 * ps3_send_event_locally() to signal events.
332 int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu, unsigned int *virq)
337 result = lv1_construct_event_receive_port(&outlet);
340 FAIL("%s:%d: lv1_construct_event_receive_port failed: %s\n",
341 __func__, __LINE__, ps3_result(result));
346 result = ps3_irq_plug_setup(cpu, outlet, virq);
351 EXPORT_SYMBOL_GPL(ps3_event_receive_port_setup);
354 * ps3_event_receive_port_destroy - Destroy an event receive port.
355 * @virq: The assigned Linux virq.
357 * Since ps3_event_receive_port_destroy destroys the receive port outlet,
358 * SB devices need to call disconnect_interrupt_event_receive_port() before
362 int ps3_event_receive_port_destroy(unsigned int virq)
366 DBG(" -> %s:%d virq %u\n", __func__, __LINE__, virq);
368 ps3_chip_mask(irq_get_irq_data(virq));
370 result = lv1_destruct_event_receive_port(virq_to_hw(virq));
373 FAIL("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
374 __func__, __LINE__, ps3_result(result));
377 * Don't call ps3_virq_destroy() here since ps3_smp_cleanup_cpu()
378 * calls from interrupt context (smp_call_function) when kexecing.
381 DBG(" <- %s:%d\n", __func__, __LINE__);
385 int ps3_send_event_locally(unsigned int virq)
387 return lv1_send_event_locally(virq_to_hw(virq));
391 * ps3_sb_event_receive_port_setup - Setup a system bus event receive port.
392 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
394 * @dev: The system bus device instance.
395 * @virq: The assigned Linux virq.
397 * An event irq represents a virtual device interrupt. The interrupt_id
398 * coresponds to the software interrupt number.
401 int ps3_sb_event_receive_port_setup(struct ps3_system_bus_device *dev,
402 enum ps3_cpu_binding cpu, unsigned int *virq)
404 /* this should go in system-bus.c */
408 result = ps3_event_receive_port_setup(cpu, virq);
413 result = lv1_connect_interrupt_event_receive_port(dev->bus_id,
414 dev->dev_id, virq_to_hw(*virq), dev->interrupt_id);
417 FAIL("%s:%d: lv1_connect_interrupt_event_receive_port"
418 " failed: %s\n", __func__, __LINE__,
420 ps3_event_receive_port_destroy(*virq);
425 DBG("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
426 dev->interrupt_id, *virq);
430 EXPORT_SYMBOL(ps3_sb_event_receive_port_setup);
432 int ps3_sb_event_receive_port_destroy(struct ps3_system_bus_device *dev,
435 /* this should go in system-bus.c */
439 DBG(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
440 dev->interrupt_id, virq);
442 result = lv1_disconnect_interrupt_event_receive_port(dev->bus_id,
443 dev->dev_id, virq_to_hw(virq), dev->interrupt_id);
446 FAIL("%s:%d: lv1_disconnect_interrupt_event_receive_port"
447 " failed: %s\n", __func__, __LINE__,
450 result = ps3_event_receive_port_destroy(virq);
454 * ps3_event_receive_port_destroy() destroys the IRQ plug,
455 * so don't call ps3_irq_plug_destroy() here.
458 result = ps3_virq_destroy(virq);
461 DBG(" <- %s:%d\n", __func__, __LINE__);
464 EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy);
467 * ps3_io_irq_setup - Setup a system bus io irq.
468 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
470 * @interrupt_id: The device interrupt id read from the system repository.
471 * @virq: The assigned Linux virq.
473 * An io irq represents a non-virtualized device interrupt. interrupt_id
474 * coresponds to the interrupt number of the interrupt controller.
477 int ps3_io_irq_setup(enum ps3_cpu_binding cpu, unsigned int interrupt_id,
483 result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
486 FAIL("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
487 __func__, __LINE__, ps3_result(result));
491 result = ps3_irq_plug_setup(cpu, outlet, virq);
496 EXPORT_SYMBOL_GPL(ps3_io_irq_setup);
498 int ps3_io_irq_destroy(unsigned int virq)
501 unsigned long outlet = virq_to_hw(virq);
503 ps3_chip_mask(irq_get_irq_data(virq));
506 * lv1_destruct_io_irq_outlet() will destroy the IRQ plug,
507 * so call ps3_irq_plug_destroy() first.
510 result = ps3_irq_plug_destroy(virq);
513 result = lv1_destruct_io_irq_outlet(outlet);
516 FAIL("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
517 __func__, __LINE__, ps3_result(result));
521 EXPORT_SYMBOL_GPL(ps3_io_irq_destroy);
524 * ps3_vuart_irq_setup - Setup the system virtual uart virq.
525 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
527 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
528 * @virq: The assigned Linux virq.
530 * The system supports only a single virtual uart, so multiple calls without
531 * freeing the interrupt will return a wrong state error.
534 int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu, void* virt_addr_bmp,
541 BUG_ON(!is_kernel_addr((u64)virt_addr_bmp));
543 lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));
545 result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);
548 FAIL("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
549 __func__, __LINE__, ps3_result(result));
553 result = ps3_irq_plug_setup(cpu, outlet, virq);
558 EXPORT_SYMBOL_GPL(ps3_vuart_irq_setup);
560 int ps3_vuart_irq_destroy(unsigned int virq)
564 ps3_chip_mask(irq_get_irq_data(virq));
565 result = lv1_deconfigure_virtual_uart_irq();
568 FAIL("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
569 __func__, __LINE__, ps3_result(result));
573 result = ps3_irq_plug_destroy(virq);
578 EXPORT_SYMBOL_GPL(ps3_vuart_irq_destroy);
581 * ps3_spe_irq_setup - Setup an spe virq.
582 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
584 * @spe_id: The spe_id returned from lv1_construct_logical_spe().
585 * @class: The spe interrupt class {0,1,2}.
586 * @virq: The assigned Linux virq.
590 int ps3_spe_irq_setup(enum ps3_cpu_binding cpu, unsigned long spe_id,
591 unsigned int class, unsigned int *virq)
598 result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);
601 FAIL("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
602 __func__, __LINE__, ps3_result(result));
606 result = ps3_irq_plug_setup(cpu, outlet, virq);
612 int ps3_spe_irq_destroy(unsigned int virq)
616 ps3_chip_mask(irq_get_irq_data(virq));
618 result = ps3_irq_plug_destroy(virq);
625 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
626 #define PS3_PLUG_MAX 63
629 static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu,
630 const char* func, int line)
632 pr_debug("%s:%d: %s %u {%04llx_%04llx_%04llx_%04llx}\n",
633 func, line, header, cpu,
634 *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
638 static void __maybe_unused _dump_256_bmp(const char *header,
639 const u64 *p, unsigned cpu, const char* func, int line)
641 pr_debug("%s:%d: %s %u {%016llx:%016llx:%016llx:%016llx}\n",
642 func, line, header, cpu, p[0], p[1], p[2], p[3]);
645 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
646 static void _dump_bmp(struct ps3_private* pd, const char* func, int line)
650 spin_lock_irqsave(&pd->bmp_lock, flags);
651 _dump_64_bmp("stat", &pd->bmp.status, pd->thread_id, func, line);
652 _dump_64_bmp("mask", (u64*)&pd->bmp.mask, pd->thread_id, func, line);
653 spin_unlock_irqrestore(&pd->bmp_lock, flags);
656 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
657 static void __maybe_unused _dump_mask(struct ps3_private *pd,
658 const char* func, int line)
662 spin_lock_irqsave(&pd->bmp_lock, flags);
663 _dump_64_bmp("mask", (u64*)&pd->bmp.mask, pd->thread_id, func, line);
664 spin_unlock_irqrestore(&pd->bmp_lock, flags);
667 static void dump_bmp(struct ps3_private* pd) {};
668 #endif /* defined(DEBUG) */
670 static int ps3_host_map(struct irq_domain *h, unsigned int virq,
671 irq_hw_number_t hwirq)
673 DBG("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq,
676 irq_set_chip_and_handler(virq, &ps3_irq_chip, handle_fasteoi_irq);
681 static int ps3_host_match(struct irq_domain *h, struct device_node *np)
687 static const struct irq_domain_ops ps3_host_ops = {
689 .match = ps3_host_match,
692 void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
694 struct ps3_private *pd = &per_cpu(ps3_private, cpu);
696 set_bit(63 - virq, &pd->ipi_debug_brk_mask);
698 DBG("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
699 cpu, virq, pd->ipi_debug_brk_mask);
702 void __init ps3_register_ipi_irq(unsigned int cpu, unsigned int virq)
704 struct ps3_private *pd = &per_cpu(ps3_private, cpu);
706 set_bit(63 - virq, &pd->ipi_mask);
708 DBG("%s:%d: cpu %u, virq %u, ipi_mask %lxh\n", __func__, __LINE__,
709 cpu, virq, pd->ipi_mask);
712 static unsigned int ps3_get_irq(void)
714 struct ps3_private *pd = &__get_cpu_var(ps3_private);
715 u64 x = (pd->bmp.status & pd->bmp.mask);
718 /* check for ipi break first to stop this cpu ASAP */
720 if (x & pd->ipi_debug_brk_mask)
721 x &= pd->ipi_debug_brk_mask;
723 asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x));
726 if (unlikely(plug == NO_IRQ)) {
727 DBG("%s:%d: no plug found: thread_id %llu\n", __func__,
728 __LINE__, pd->thread_id);
729 dump_bmp(&per_cpu(ps3_private, 0));
730 dump_bmp(&per_cpu(ps3_private, 1));
735 if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) {
736 dump_bmp(&per_cpu(ps3_private, 0));
737 dump_bmp(&per_cpu(ps3_private, 1));
742 /* IPIs are EOIed here. */
744 if (test_bit(63 - plug, &pd->ipi_mask))
745 lv1_end_of_interrupt_ext(pd->ppe_id, pd->thread_id, plug);
750 void __init ps3_init_IRQ(void)
754 struct irq_domain *host;
756 host = irq_domain_add_nomap(NULL, PS3_PLUG_MAX + 1, &ps3_host_ops, NULL);
757 irq_set_default_host(host);
759 for_each_possible_cpu(cpu) {
760 struct ps3_private *pd = &per_cpu(ps3_private, cpu);
762 lv1_get_logical_ppe_id(&pd->ppe_id);
763 pd->thread_id = get_hard_smp_processor_id(cpu);
764 spin_lock_init(&pd->bmp_lock);
766 DBG("%s:%d: ppe_id %llu, thread_id %llu, bmp %lxh\n",
767 __func__, __LINE__, pd->ppe_id, pd->thread_id,
768 ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
770 result = lv1_configure_irq_state_bitmap(pd->ppe_id,
771 pd->thread_id, ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
774 FAIL("%s:%d: lv1_configure_irq_state_bitmap failed:"
775 " %s\n", __func__, __LINE__,
779 ppc_md.get_irq = ps3_get_irq;
782 void ps3_shutdown_IRQ(int cpu)
786 u64 thread_id = get_hard_smp_processor_id(cpu);
788 lv1_get_logical_ppe_id(&ppe_id);
789 result = lv1_configure_irq_state_bitmap(ppe_id, thread_id, 0);
791 DBG("%s:%d: lv1_configure_irq_state_bitmap (%llu:%llu/%d) %s\n", __func__,
792 __LINE__, ppe_id, thread_id, cpu, ps3_result(result));