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(fmt...) udbg_printf(fmt)
35 #define DBG(fmt...) do{if(0)printk(fmt);}while(0)
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 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
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
65 #define PS3_BMP_MINALIGN 64
74 u64 ipi_debug_brk_mask
;
79 * struct ps3_private - a per cpu data structure
80 * @bmp: ps3_bmp structure
81 * @node: HV logical_ppe_id
86 struct ps3_bmp bmp
__attribute__ ((aligned (PS3_BMP_MINALIGN
)));
91 static DEFINE_PER_CPU(struct ps3_private
, ps3_private
);
94 * ps3_virq_setup - virq related setup.
95 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
97 * @outlet: The HV outlet from the various create outlet routines.
98 * @virq: The assigned Linux virq.
100 * Calls irq_create_mapping() to get a virq and sets the chip data to
104 int ps3_virq_setup(enum ps3_cpu_binding cpu
, unsigned long outlet
,
108 struct ps3_private
*pd
;
110 /* This defines the default interrupt distribution policy. */
112 if (cpu
== PS3_BINDING_CPU_ANY
)
115 pd
= &per_cpu(ps3_private
, cpu
);
117 *virq
= irq_create_mapping(NULL
, outlet
);
119 if (*virq
== NO_IRQ
) {
120 pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
121 __func__
, __LINE__
, outlet
);
126 pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__
, __LINE__
,
129 result
= set_irq_chip_data(*virq
, pd
);
132 pr_debug("%s:%d: set_irq_chip_data failed\n",
140 irq_dispose_mapping(*virq
);
146 * ps3_virq_destroy - virq related teardown.
147 * @virq: The assigned Linux virq.
149 * Clears chip data and calls irq_dispose_mapping() for the virq.
152 int ps3_virq_destroy(unsigned int virq
)
154 const struct ps3_private
*pd
= get_irq_chip_data(virq
);
156 pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__
, __LINE__
,
157 pd
->node
, pd
->cpu
, virq
);
159 set_irq_chip_data(virq
, NULL
);
160 irq_dispose_mapping(virq
);
162 pr_debug("%s:%d <-\n", __func__
, __LINE__
);
167 * ps3_irq_plug_setup - Generic outlet and virq related setup.
168 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
170 * @outlet: The HV outlet from the various create outlet routines.
171 * @virq: The assigned Linux virq.
173 * Sets up virq and connects the irq plug.
176 int ps3_irq_plug_setup(enum ps3_cpu_binding cpu
, unsigned long outlet
,
180 struct ps3_private
*pd
;
182 result
= ps3_virq_setup(cpu
, outlet
, virq
);
185 pr_debug("%s:%d: ps3_virq_setup failed\n", __func__
, __LINE__
);
189 pd
= get_irq_chip_data(*virq
);
191 /* Binds outlet to cpu + virq. */
193 result
= lv1_connect_irq_plug_ext(pd
->node
, pd
->cpu
, *virq
, outlet
, 0);
196 pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
197 __func__
, __LINE__
, ps3_result(result
));
205 ps3_virq_destroy(*virq
);
209 EXPORT_SYMBOL_GPL(ps3_irq_plug_setup
);
212 * ps3_irq_plug_destroy - Generic outlet and virq related teardown.
213 * @virq: The assigned Linux virq.
215 * Disconnects the irq plug and tears down virq.
216 * Do not call for system bus event interrupts setup with
217 * ps3_sb_event_receive_port_setup().
220 int ps3_irq_plug_destroy(unsigned int virq
)
223 const struct ps3_private
*pd
= get_irq_chip_data(virq
);
225 pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__
, __LINE__
,
226 pd
->node
, pd
->cpu
, virq
);
228 result
= lv1_disconnect_irq_plug_ext(pd
->node
, pd
->cpu
, virq
);
231 pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
232 __func__
, __LINE__
, ps3_result(result
));
234 ps3_virq_destroy(virq
);
238 EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy
);
241 * ps3_event_receive_port_setup - Setup an event receive port.
242 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
244 * @virq: The assigned Linux virq.
246 * The virq can be used with lv1_connect_interrupt_event_receive_port() to
247 * arrange to receive interrupts from system-bus devices, or with
248 * ps3_send_event_locally() to signal events.
251 int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu
, unsigned int *virq
)
254 unsigned long outlet
;
256 result
= lv1_construct_event_receive_port(&outlet
);
259 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
260 __func__
, __LINE__
, ps3_result(result
));
265 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
270 EXPORT_SYMBOL_GPL(ps3_event_receive_port_setup
);
273 * ps3_event_receive_port_destroy - Destroy an event receive port.
274 * @virq: The assigned Linux virq.
276 * Since ps3_event_receive_port_destroy destroys the receive port outlet,
277 * SB devices need to call disconnect_interrupt_event_receive_port() before
281 int ps3_event_receive_port_destroy(unsigned int virq
)
285 pr_debug(" -> %s:%d virq: %u\n", __func__
, __LINE__
, virq
);
287 result
= lv1_destruct_event_receive_port(virq_to_hw(virq
));
290 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
291 __func__
, __LINE__
, ps3_result(result
));
293 /* lv1_destruct_event_receive_port() destroys the IRQ plug,
294 * so don't call ps3_irq_plug_destroy() here.
297 result
= ps3_virq_destroy(virq
);
300 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
303 EXPORT_SYMBOL_GPL(ps3_event_receive_port_destroy
);
305 int ps3_send_event_locally(unsigned int virq
)
307 return lv1_send_event_locally(virq_to_hw(virq
));
311 * ps3_sb_event_receive_port_setup - Setup a system bus event receive port.
312 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
314 * @did: The HV device identifier read from the system repository.
315 * @interrupt_id: The device interrupt id read from the system repository.
316 * @virq: The assigned Linux virq.
318 * An event irq represents a virtual device interrupt. The interrupt_id
319 * coresponds to the software interrupt number.
322 int ps3_sb_event_receive_port_setup(enum ps3_cpu_binding cpu
,
323 const struct ps3_device_id
*did
, unsigned int interrupt_id
,
326 /* this should go in system-bus.c */
330 result
= ps3_event_receive_port_setup(cpu
, virq
);
335 result
= lv1_connect_interrupt_event_receive_port(did
->bus_id
,
336 did
->dev_id
, virq_to_hw(*virq
), interrupt_id
);
339 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
340 " failed: %s\n", __func__
, __LINE__
,
342 ps3_event_receive_port_destroy(*virq
);
347 pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
348 interrupt_id
, *virq
);
352 EXPORT_SYMBOL(ps3_sb_event_receive_port_setup
);
354 int ps3_sb_event_receive_port_destroy(const struct ps3_device_id
*did
,
355 unsigned int interrupt_id
, unsigned int virq
)
357 /* this should go in system-bus.c */
361 pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
364 result
= lv1_disconnect_interrupt_event_receive_port(did
->bus_id
,
365 did
->dev_id
, virq_to_hw(virq
), interrupt_id
);
368 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
369 " failed: %s\n", __func__
, __LINE__
,
372 result
= ps3_event_receive_port_destroy(virq
);
375 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
378 EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy
);
381 * ps3_io_irq_setup - Setup a system bus io irq.
382 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
384 * @interrupt_id: The device interrupt id read from the system repository.
385 * @virq: The assigned Linux virq.
387 * An io irq represents a non-virtualized device interrupt. interrupt_id
388 * coresponds to the interrupt number of the interrupt controller.
391 int ps3_io_irq_setup(enum ps3_cpu_binding cpu
, unsigned int interrupt_id
,
395 unsigned long outlet
;
397 result
= lv1_construct_io_irq_outlet(interrupt_id
, &outlet
);
400 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
401 __func__
, __LINE__
, ps3_result(result
));
405 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
410 EXPORT_SYMBOL_GPL(ps3_io_irq_setup
);
412 int ps3_io_irq_destroy(unsigned int virq
)
416 result
= lv1_destruct_io_irq_outlet(virq_to_hw(virq
));
419 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
420 __func__
, __LINE__
, ps3_result(result
));
422 result
= ps3_irq_plug_destroy(virq
);
427 EXPORT_SYMBOL_GPL(ps3_io_irq_destroy
);
430 * ps3_vuart_irq_setup - Setup the system virtual uart virq.
431 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
433 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
434 * @virq: The assigned Linux virq.
436 * The system supports only a single virtual uart, so multiple calls without
437 * freeing the interrupt will return a wrong state error.
440 int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu
, void* virt_addr_bmp
,
444 unsigned long outlet
;
447 BUG_ON(!is_kernel_addr((u64
)virt_addr_bmp
));
449 lpar_addr
= ps3_mm_phys_to_lpar(__pa(virt_addr_bmp
));
451 result
= lv1_configure_virtual_uart_irq(lpar_addr
, &outlet
);
454 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
455 __func__
, __LINE__
, ps3_result(result
));
459 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
465 int ps3_vuart_irq_destroy(unsigned int virq
)
469 result
= lv1_deconfigure_virtual_uart_irq();
472 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
473 __func__
, __LINE__
, ps3_result(result
));
477 result
= ps3_irq_plug_destroy(virq
);
484 * ps3_spe_irq_setup - Setup an spe virq.
485 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
487 * @spe_id: The spe_id returned from lv1_construct_logical_spe().
488 * @class: The spe interrupt class {0,1,2}.
489 * @virq: The assigned Linux virq.
493 int ps3_spe_irq_setup(enum ps3_cpu_binding cpu
, unsigned long spe_id
,
494 unsigned int class, unsigned int *virq
)
497 unsigned long outlet
;
501 result
= lv1_get_spe_irq_outlet(spe_id
, class, &outlet
);
504 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
505 __func__
, __LINE__
, ps3_result(result
));
509 result
= ps3_irq_plug_setup(cpu
, outlet
, virq
);
515 int ps3_spe_irq_destroy(unsigned int virq
)
517 int result
= ps3_irq_plug_destroy(virq
);
523 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
524 #define PS3_PLUG_MAX 63
527 static void _dump_64_bmp(const char *header
, const u64
*p
, unsigned cpu
,
528 const char* func
, int line
)
530 pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
531 func
, line
, header
, cpu
,
532 *p
>> 48, (*p
>> 32) & 0xffff, (*p
>> 16) & 0xffff,
536 static void __attribute__ ((unused
)) _dump_256_bmp(const char *header
,
537 const u64
*p
, unsigned cpu
, const char* func
, int line
)
539 pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
540 func
, line
, header
, cpu
, p
[0], p
[1], p
[2], p
[3]);
543 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
544 static void _dump_bmp(struct ps3_private
* pd
, const char* func
, int line
)
548 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
549 _dump_64_bmp("stat", &pd
->bmp
.status
, pd
->cpu
, func
, line
);
550 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->cpu
, func
, line
);
551 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
554 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
555 static void __attribute__ ((unused
)) _dump_mask(struct ps3_private
* pd
,
556 const char* func
, int line
)
560 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
561 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->cpu
, func
, line
);
562 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
565 static void dump_bmp(struct ps3_private
* pd
) {};
566 #endif /* defined(DEBUG) */
568 static void ps3_chip_mask(unsigned int virq
)
570 struct ps3_private
*pd
= get_irq_chip_data(virq
);
571 u64 bit
= 0x8000000000000000UL
>> virq
;
572 u64
*p
= &pd
->bmp
.mask
;
576 pr_debug("%s:%d: cpu %u, virq %d\n", __func__
, __LINE__
, pd
->cpu
, virq
);
578 local_irq_save(flags
);
584 : "=&r" (old
), "+m" (*p
)
588 lv1_did_update_interrupt_mask(pd
->node
, pd
->cpu
);
589 local_irq_restore(flags
);
592 static void ps3_chip_unmask(unsigned int virq
)
594 struct ps3_private
*pd
= get_irq_chip_data(virq
);
595 u64 bit
= 0x8000000000000000UL
>> virq
;
596 u64
*p
= &pd
->bmp
.mask
;
600 pr_debug("%s:%d: cpu %u, virq %d\n", __func__
, __LINE__
, pd
->cpu
, virq
);
602 local_irq_save(flags
);
608 : "=&r" (old
), "+m" (*p
)
612 lv1_did_update_interrupt_mask(pd
->node
, pd
->cpu
);
613 local_irq_restore(flags
);
616 static void ps3_chip_eoi(unsigned int virq
)
618 const struct ps3_private
*pd
= get_irq_chip_data(virq
);
619 lv1_end_of_interrupt_ext(pd
->node
, pd
->cpu
, virq
);
622 static struct irq_chip irq_chip
= {
624 .mask
= ps3_chip_mask
,
625 .unmask
= ps3_chip_unmask
,
629 static void ps3_host_unmap(struct irq_host
*h
, unsigned int virq
)
631 set_irq_chip_data(virq
, NULL
);
634 static int ps3_host_map(struct irq_host
*h
, unsigned int virq
,
635 irq_hw_number_t hwirq
)
637 pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__
, __LINE__
, hwirq
,
640 set_irq_chip_and_handler(virq
, &irq_chip
, handle_fasteoi_irq
);
645 static struct irq_host_ops ps3_host_ops
= {
647 .unmap
= ps3_host_unmap
,
650 void __init
ps3_register_ipi_debug_brk(unsigned int cpu
, unsigned int virq
)
652 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
654 pd
->bmp
.ipi_debug_brk_mask
= 0x8000000000000000UL
>> virq
;
656 pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__
, __LINE__
,
657 cpu
, virq
, pd
->bmp
.ipi_debug_brk_mask
);
660 unsigned int ps3_get_irq(void)
662 struct ps3_private
*pd
= &__get_cpu_var(ps3_private
);
663 u64 x
= (pd
->bmp
.status
& pd
->bmp
.mask
);
666 /* check for ipi break first to stop this cpu ASAP */
668 if (x
& pd
->bmp
.ipi_debug_brk_mask
)
669 x
&= pd
->bmp
.ipi_debug_brk_mask
;
671 asm volatile("cntlzd %0,%1" : "=r" (plug
) : "r" (x
));
674 if (unlikely(plug
) == NO_IRQ
) {
675 pr_debug("%s:%d: no plug found: cpu %u\n", __func__
, __LINE__
,
677 dump_bmp(&per_cpu(ps3_private
, 0));
678 dump_bmp(&per_cpu(ps3_private
, 1));
683 if (unlikely(plug
< NUM_ISA_INTERRUPTS
|| plug
> PS3_PLUG_MAX
)) {
684 dump_bmp(&per_cpu(ps3_private
, 0));
685 dump_bmp(&per_cpu(ps3_private
, 1));
692 void __init
ps3_init_IRQ(void)
696 struct irq_host
*host
;
698 host
= irq_alloc_host(IRQ_HOST_MAP_NOMAP
, 0, &ps3_host_ops
,
700 irq_set_default_host(host
);
701 irq_set_virq_count(PS3_PLUG_MAX
+ 1);
703 for_each_possible_cpu(cpu
) {
704 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
706 lv1_get_logical_ppe_id(&pd
->node
);
707 pd
->cpu
= get_hard_smp_processor_id(cpu
);
708 spin_lock_init(&pd
->bmp
.lock
);
710 pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__
,
711 __LINE__
, pd
->node
, pd
->cpu
,
712 ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
714 result
= lv1_configure_irq_state_bitmap(pd
->node
, pd
->cpu
,
715 ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
718 pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
719 " %s\n", __func__
, __LINE__
,
723 ppc_md
.get_irq
= ps3_get_irq
;