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/module.h>
23 #include <linux/irq.h>
25 #include <asm/machdep.h>
27 #include <asm/lv1call.h>
33 #define DBG udbg_printf
39 * struct ps3_bmp - a per cpu irq status and mask bitmap structure
40 * @status: 256 bit status bitmap indexed by plug
42 * @mask: 256 bit mask bitmap indexed by plug
45 * @ipi_debug_brk_mask:
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
76 u64 ipi_debug_brk_mask
;
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
88 struct ps3_bmp bmp
__attribute__ ((aligned (PS3_BMP_MINALIGN
)));
93 static DEFINE_PER_CPU(struct ps3_private
, ps3_private
);
96 * ps3_chip_mask - Set an interrupt mask bit in ps3_bmp.
97 * @virq: The assigned Linux virq.
99 * Sets ps3_bmp.mask and calls lv1_did_update_interrupt_mask().
102 static void ps3_chip_mask(struct irq_data
*d
)
104 struct ps3_private
*pd
= irq_data_get_irq_chip_data(d
);
107 pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__
, __LINE__
,
108 pd
->thread_id
, d
->irq
);
110 local_irq_save(flags
);
111 clear_bit(63 - d
->irq
, &pd
->bmp
.mask
);
112 lv1_did_update_interrupt_mask(pd
->ppe_id
, pd
->thread_id
);
113 local_irq_restore(flags
);
117 * ps3_chip_unmask - Clear an interrupt mask bit in ps3_bmp.
118 * @virq: The assigned Linux virq.
120 * Clears ps3_bmp.mask and calls lv1_did_update_interrupt_mask().
123 static void ps3_chip_unmask(struct irq_data
*d
)
125 struct ps3_private
*pd
= irq_data_get_irq_chip_data(d
);
128 pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__
, __LINE__
,
129 pd
->thread_id
, d
->irq
);
131 local_irq_save(flags
);
132 set_bit(63 - d
->irq
, &pd
->bmp
.mask
);
133 lv1_did_update_interrupt_mask(pd
->ppe_id
, pd
->thread_id
);
134 local_irq_restore(flags
);
138 * ps3_chip_eoi - HV end-of-interrupt.
139 * @virq: The assigned Linux virq.
141 * Calls lv1_end_of_interrupt_ext().
144 static void ps3_chip_eoi(struct irq_data
*d
)
146 const struct ps3_private
*pd
= irq_data_get_irq_chip_data(d
);
147 lv1_end_of_interrupt_ext(pd
->ppe_id
, pd
->thread_id
, d
->irq
);
151 * ps3_irq_chip - Represents the ps3_bmp as a Linux struct irq_chip.
154 static struct irq_chip ps3_irq_chip
= {
156 .irq_mask
= ps3_chip_mask
,
157 .irq_unmask
= ps3_chip_unmask
,
158 .irq_eoi
= ps3_chip_eoi
,
162 * ps3_virq_setup - virq related setup.
163 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
165 * @outlet: The HV outlet from the various create outlet routines.
166 * @virq: The assigned Linux virq.
168 * Calls irq_create_mapping() to get a virq and sets the chip data to
172 static int ps3_virq_setup(enum ps3_cpu_binding cpu
, unsigned long outlet
,
176 struct ps3_private
*pd
;
178 /* This defines the default interrupt distribution policy. */
180 if (cpu
== PS3_BINDING_CPU_ANY
)
183 pd
= &per_cpu(ps3_private
, cpu
);
185 *virq
= irq_create_mapping(NULL
, outlet
);
187 if (*virq
== NO_IRQ
) {
188 pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
189 __func__
, __LINE__
, outlet
);
194 pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__
, __LINE__
,
197 result
= irq_set_chip_data(*virq
, pd
);
200 pr_debug("%s:%d: irq_set_chip_data failed\n",
205 ps3_chip_mask(irq_get_irq_data(*virq
));
210 irq_dispose_mapping(*virq
);
216 * ps3_virq_destroy - virq related teardown.
217 * @virq: The assigned Linux virq.
219 * Clears chip data and calls irq_dispose_mapping() for the virq.
222 static int ps3_virq_destroy(unsigned int virq
)
224 const struct ps3_private
*pd
= irq_get_chip_data(virq
);
226 pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__
,
227 __LINE__
, pd
->ppe_id
, pd
->thread_id
, virq
);
229 irq_set_chip_data(virq
, NULL
);
230 irq_dispose_mapping(virq
);
232 pr_debug("%s:%d <-\n", __func__
, __LINE__
);
237 * ps3_irq_plug_setup - Generic outlet and virq related setup.
238 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
240 * @outlet: The HV outlet from the various create outlet routines.
241 * @virq: The assigned Linux virq.
243 * Sets up virq and connects the irq plug.
246 int ps3_irq_plug_setup(enum ps3_cpu_binding cpu
, unsigned long outlet
,
250 struct ps3_private
*pd
;
252 result
= ps3_virq_setup(cpu
, outlet
, virq
);
255 pr_debug("%s:%d: ps3_virq_setup failed\n", __func__
, __LINE__
);
259 pd
= irq_get_chip_data(*virq
);
261 /* Binds outlet to cpu + virq. */
263 result
= lv1_connect_irq_plug_ext(pd
->ppe_id
, pd
->thread_id
, *virq
,
267 pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
268 __func__
, __LINE__
, ps3_result(result
));
276 ps3_virq_destroy(*virq
);
280 EXPORT_SYMBOL_GPL(ps3_irq_plug_setup
);
283 * ps3_irq_plug_destroy - Generic outlet and virq related teardown.
284 * @virq: The assigned Linux virq.
286 * Disconnects the irq plug and tears down virq.
287 * Do not call for system bus event interrupts setup with
288 * ps3_sb_event_receive_port_setup().
291 int ps3_irq_plug_destroy(unsigned int virq
)
294 const struct ps3_private
*pd
= irq_get_chip_data(virq
);
296 pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__
,
297 __LINE__
, pd
->ppe_id
, pd
->thread_id
, virq
);
299 ps3_chip_mask(irq_get_irq_data(virq
));
301 result
= lv1_disconnect_irq_plug_ext(pd
->ppe_id
, pd
->thread_id
, virq
);
304 pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
305 __func__
, __LINE__
, ps3_result(result
));
307 ps3_virq_destroy(virq
);
311 EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy
);
314 * ps3_event_receive_port_setup - Setup an event receive port.
315 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
317 * @virq: The assigned Linux virq.
319 * The virq can be used with lv1_connect_interrupt_event_receive_port() to
320 * arrange to receive interrupts from system-bus devices, or with
321 * ps3_send_event_locally() to signal events.
324 int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu
, unsigned int *virq
)
329 result
= lv1_construct_event_receive_port(&outlet
);
332 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
333 __func__
, __LINE__
, ps3_result(result
));
338 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
343 EXPORT_SYMBOL_GPL(ps3_event_receive_port_setup
);
346 * ps3_event_receive_port_destroy - Destroy an event receive port.
347 * @virq: The assigned Linux virq.
349 * Since ps3_event_receive_port_destroy destroys the receive port outlet,
350 * SB devices need to call disconnect_interrupt_event_receive_port() before
354 int ps3_event_receive_port_destroy(unsigned int virq
)
358 pr_debug(" -> %s:%d virq %u\n", __func__
, __LINE__
, virq
);
360 ps3_chip_mask(irq_get_irq_data(virq
));
362 result
= lv1_destruct_event_receive_port(virq_to_hw(virq
));
365 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
366 __func__
, __LINE__
, ps3_result(result
));
369 * Don't call ps3_virq_destroy() here since ps3_smp_cleanup_cpu()
370 * calls from interrupt context (smp_call_function) when kexecing.
373 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
377 int ps3_send_event_locally(unsigned int virq
)
379 return lv1_send_event_locally(virq_to_hw(virq
));
383 * ps3_sb_event_receive_port_setup - Setup a system bus event receive port.
384 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
386 * @dev: The system bus device instance.
387 * @virq: The assigned Linux virq.
389 * An event irq represents a virtual device interrupt. The interrupt_id
390 * coresponds to the software interrupt number.
393 int ps3_sb_event_receive_port_setup(struct ps3_system_bus_device
*dev
,
394 enum ps3_cpu_binding cpu
, unsigned int *virq
)
396 /* this should go in system-bus.c */
400 result
= ps3_event_receive_port_setup(cpu
, virq
);
405 result
= lv1_connect_interrupt_event_receive_port(dev
->bus_id
,
406 dev
->dev_id
, virq_to_hw(*virq
), dev
->interrupt_id
);
409 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
410 " failed: %s\n", __func__
, __LINE__
,
412 ps3_event_receive_port_destroy(*virq
);
417 pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
418 dev
->interrupt_id
, *virq
);
422 EXPORT_SYMBOL(ps3_sb_event_receive_port_setup
);
424 int ps3_sb_event_receive_port_destroy(struct ps3_system_bus_device
*dev
,
427 /* this should go in system-bus.c */
431 pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
432 dev
->interrupt_id
, virq
);
434 result
= lv1_disconnect_interrupt_event_receive_port(dev
->bus_id
,
435 dev
->dev_id
, virq_to_hw(virq
), dev
->interrupt_id
);
438 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
439 " failed: %s\n", __func__
, __LINE__
,
442 result
= ps3_event_receive_port_destroy(virq
);
446 * ps3_event_receive_port_destroy() destroys the IRQ plug,
447 * so don't call ps3_irq_plug_destroy() here.
450 result
= ps3_virq_destroy(virq
);
453 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
456 EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy
);
459 * ps3_io_irq_setup - Setup a system bus io irq.
460 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
462 * @interrupt_id: The device interrupt id read from the system repository.
463 * @virq: The assigned Linux virq.
465 * An io irq represents a non-virtualized device interrupt. interrupt_id
466 * coresponds to the interrupt number of the interrupt controller.
469 int ps3_io_irq_setup(enum ps3_cpu_binding cpu
, unsigned int interrupt_id
,
475 result
= lv1_construct_io_irq_outlet(interrupt_id
, &outlet
);
478 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
479 __func__
, __LINE__
, ps3_result(result
));
483 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
488 EXPORT_SYMBOL_GPL(ps3_io_irq_setup
);
490 int ps3_io_irq_destroy(unsigned int virq
)
493 unsigned long outlet
= virq_to_hw(virq
);
495 ps3_chip_mask(irq_get_irq_data(virq
));
498 * lv1_destruct_io_irq_outlet() will destroy the IRQ plug,
499 * so call ps3_irq_plug_destroy() first.
502 result
= ps3_irq_plug_destroy(virq
);
505 result
= lv1_destruct_io_irq_outlet(outlet
);
508 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
509 __func__
, __LINE__
, ps3_result(result
));
513 EXPORT_SYMBOL_GPL(ps3_io_irq_destroy
);
516 * ps3_vuart_irq_setup - Setup the system virtual uart virq.
517 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
519 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
520 * @virq: The assigned Linux virq.
522 * The system supports only a single virtual uart, so multiple calls without
523 * freeing the interrupt will return a wrong state error.
526 int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu
, void* virt_addr_bmp
,
533 BUG_ON(!is_kernel_addr((u64
)virt_addr_bmp
));
535 lpar_addr
= ps3_mm_phys_to_lpar(__pa(virt_addr_bmp
));
537 result
= lv1_configure_virtual_uart_irq(lpar_addr
, &outlet
);
540 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
541 __func__
, __LINE__
, ps3_result(result
));
545 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
550 EXPORT_SYMBOL_GPL(ps3_vuart_irq_setup
);
552 int ps3_vuart_irq_destroy(unsigned int virq
)
556 ps3_chip_mask(irq_get_irq_data(virq
));
557 result
= lv1_deconfigure_virtual_uart_irq();
560 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
561 __func__
, __LINE__
, ps3_result(result
));
565 result
= ps3_irq_plug_destroy(virq
);
570 EXPORT_SYMBOL_GPL(ps3_vuart_irq_destroy
);
573 * ps3_spe_irq_setup - Setup an spe virq.
574 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
576 * @spe_id: The spe_id returned from lv1_construct_logical_spe().
577 * @class: The spe interrupt class {0,1,2}.
578 * @virq: The assigned Linux virq.
582 int ps3_spe_irq_setup(enum ps3_cpu_binding cpu
, unsigned long spe_id
,
583 unsigned int class, unsigned int *virq
)
590 result
= lv1_get_spe_irq_outlet(spe_id
, class, &outlet
);
593 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
594 __func__
, __LINE__
, ps3_result(result
));
598 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
604 int ps3_spe_irq_destroy(unsigned int virq
)
608 ps3_chip_mask(irq_get_irq_data(virq
));
610 result
= ps3_irq_plug_destroy(virq
);
617 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
618 #define PS3_PLUG_MAX 63
621 static void _dump_64_bmp(const char *header
, const u64
*p
, unsigned cpu
,
622 const char* func
, int line
)
624 pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
625 func
, line
, header
, cpu
,
626 *p
>> 48, (*p
>> 32) & 0xffff, (*p
>> 16) & 0xffff,
630 static void __maybe_unused
_dump_256_bmp(const char *header
,
631 const u64
*p
, unsigned cpu
, const char* func
, int line
)
633 pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
634 func
, line
, header
, cpu
, p
[0], p
[1], p
[2], p
[3]);
637 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
638 static void _dump_bmp(struct ps3_private
* pd
, const char* func
, int line
)
642 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
643 _dump_64_bmp("stat", &pd
->bmp
.status
, pd
->thread_id
, func
, line
);
644 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->thread_id
, func
, line
);
645 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
648 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
649 static void __maybe_unused
_dump_mask(struct ps3_private
*pd
,
650 const char* func
, int line
)
654 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
655 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->thread_id
, func
, line
);
656 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
659 static void dump_bmp(struct ps3_private
* pd
) {};
660 #endif /* defined(DEBUG) */
662 static int ps3_host_map(struct irq_host
*h
, unsigned int virq
,
663 irq_hw_number_t hwirq
)
665 pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__
, __LINE__
, hwirq
,
668 irq_set_chip_and_handler(virq
, &ps3_irq_chip
, handle_fasteoi_irq
);
673 static int ps3_host_match(struct irq_host
*h
, struct device_node
*np
)
679 static struct irq_host_ops ps3_host_ops
= {
681 .match
= ps3_host_match
,
684 void __init
ps3_register_ipi_debug_brk(unsigned int cpu
, unsigned int virq
)
686 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
688 pd
->bmp
.ipi_debug_brk_mask
= 0x8000000000000000UL
>> virq
;
690 pr_debug("%s:%d: cpu %u, virq %u, mask %llxh\n", __func__
, __LINE__
,
691 cpu
, virq
, pd
->bmp
.ipi_debug_brk_mask
);
694 static unsigned int ps3_get_irq(void)
696 struct ps3_private
*pd
= &__get_cpu_var(ps3_private
);
697 u64 x
= (pd
->bmp
.status
& pd
->bmp
.mask
);
700 /* check for ipi break first to stop this cpu ASAP */
702 if (x
& pd
->bmp
.ipi_debug_brk_mask
)
703 x
&= pd
->bmp
.ipi_debug_brk_mask
;
705 asm volatile("cntlzd %0,%1" : "=r" (plug
) : "r" (x
));
708 if (unlikely(plug
== NO_IRQ
)) {
709 pr_debug("%s:%d: no plug found: thread_id %llu\n", __func__
,
710 __LINE__
, pd
->thread_id
);
711 dump_bmp(&per_cpu(ps3_private
, 0));
712 dump_bmp(&per_cpu(ps3_private
, 1));
717 if (unlikely(plug
< NUM_ISA_INTERRUPTS
|| plug
> PS3_PLUG_MAX
)) {
718 dump_bmp(&per_cpu(ps3_private
, 0));
719 dump_bmp(&per_cpu(ps3_private
, 1));
726 void __init
ps3_init_IRQ(void)
730 struct irq_host
*host
;
732 host
= irq_alloc_host(NULL
, IRQ_HOST_MAP_NOMAP
, 0, &ps3_host_ops
,
734 irq_set_default_host(host
);
735 irq_set_virq_count(PS3_PLUG_MAX
+ 1);
737 for_each_possible_cpu(cpu
) {
738 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
740 lv1_get_logical_ppe_id(&pd
->ppe_id
);
741 pd
->thread_id
= get_hard_smp_processor_id(cpu
);
742 spin_lock_init(&pd
->bmp
.lock
);
744 pr_debug("%s:%d: ppe_id %llu, thread_id %llu, bmp %lxh\n",
745 __func__
, __LINE__
, pd
->ppe_id
, pd
->thread_id
,
746 ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
748 result
= lv1_configure_irq_state_bitmap(pd
->ppe_id
,
749 pd
->thread_id
, ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
752 pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
753 " %s\n", __func__
, __LINE__
,
757 ppc_md
.get_irq
= ps3_get_irq
;
760 void ps3_shutdown_IRQ(int cpu
)
764 u64 thread_id
= get_hard_smp_processor_id(cpu
);
766 lv1_get_logical_ppe_id(&ppe_id
);
767 result
= lv1_configure_irq_state_bitmap(ppe_id
, thread_id
, 0);
769 DBG("%s:%d: lv1_configure_irq_state_bitmap (%llu:%llu/%d) %s\n", __func__
,
770 __LINE__
, ppe_id
, thread_id
, cpu
, ps3_result(result
));