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>
28 #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().
52 * The HV supports 256 plugs per thread, assigned as {0..255}, for a total
53 * of 512 plugs supported on a processor. To simplify the logic this
54 * implementation equates HV plug value to Linux virq value, constrains each
55 * interrupt to have a system wide unique plug number, and limits the range
56 * of the plug values to map into the first dword of the bitmaps. This
57 * gives a usable range of plug values of {NUM_ISA_INTERRUPTS..63}. Note
58 * that there is no constraint on how many in this set an individual thread
69 u64 ipi_debug_brk_mask
;
74 * struct ps3_private - a per cpu data structure
75 * @bmp: ps3_bmp structure
76 * @node: HV logical_ppe_id
81 struct ps3_bmp bmp
__attribute__ ((aligned (64)));
86 static DEFINE_PER_CPU(struct ps3_private
, ps3_private
);
88 static int ps3_connect_irq(enum ps3_cpu_binding cpu
, unsigned long outlet
,
92 struct ps3_private
*pd
;
94 /* This defines the default interrupt distribution policy. */
96 if (cpu
== PS3_BINDING_CPU_ANY
)
99 pd
= &per_cpu(ps3_private
, cpu
);
101 *virq
= irq_create_mapping(NULL
, outlet
);
103 if (*virq
== NO_IRQ
) {
104 pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
105 __func__
, __LINE__
, outlet
);
110 /* Binds outlet to cpu + virq. */
112 result
= lv1_connect_irq_plug_ext(pd
->node
, pd
->cpu
, *virq
, outlet
, 0);
115 pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
116 __func__
, __LINE__
, ps3_result(result
));
121 pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__
, __LINE__
,
124 result
= set_irq_chip_data(*virq
, pd
);
127 pr_debug("%s:%d: set_irq_chip_data failed\n",
135 lv1_disconnect_irq_plug_ext(pd
->node
, pd
->cpu
, *virq
);
137 irq_dispose_mapping(*virq
);
142 static void ps3_disconnect_irq(unsigned int virq
)
145 const struct ps3_private
*pd
= get_irq_chip_data(virq
);
147 pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__
, __LINE__
,
148 pd
->node
, pd
->cpu
, virq
);
150 result
= lv1_disconnect_irq_plug_ext(pd
->node
, pd
->cpu
, virq
);
153 pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
154 __func__
, __LINE__
, ps3_result(result
));
156 set_irq_chip_data(virq
, NULL
);
157 irq_dispose_mapping(virq
);
161 * ps3_alloc_io_irq - Assign a virq to a system bus device.
162 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
164 * @interrupt_id: The device interrupt id read from the system repository.
165 * @virq: The assigned Linux virq.
167 * An io irq represents a non-virtualized device interrupt. interrupt_id
168 * coresponds to the interrupt number of the interrupt controller.
171 int ps3_alloc_io_irq(enum ps3_cpu_binding cpu
, unsigned int interrupt_id
,
175 unsigned long outlet
;
177 result
= lv1_construct_io_irq_outlet(interrupt_id
, &outlet
);
180 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
181 __func__
, __LINE__
, ps3_result(result
));
185 result
= ps3_connect_irq(cpu
, outlet
, virq
);
191 int ps3_free_io_irq(unsigned int virq
)
195 result
= lv1_destruct_io_irq_outlet(virq_to_hw(virq
));
198 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
199 __func__
, __LINE__
, ps3_result(result
));
201 ps3_disconnect_irq(virq
);
207 * ps3_alloc_event_irq - Allocate a virq for use with a system event.
208 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
210 * @virq: The assigned Linux virq.
212 * The virq can be used with lv1_connect_interrupt_event_receive_port() to
213 * arrange to receive events, or with ps3_send_event_locally() to signal
217 int ps3_alloc_event_irq(enum ps3_cpu_binding cpu
, unsigned int *virq
)
220 unsigned long outlet
;
222 result
= lv1_construct_event_receive_port(&outlet
);
225 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
226 __func__
, __LINE__
, ps3_result(result
));
231 result
= ps3_connect_irq(cpu
, outlet
, virq
);
237 int ps3_free_event_irq(unsigned int virq
)
241 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
243 result
= lv1_destruct_event_receive_port(virq_to_hw(virq
));
246 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
247 __func__
, __LINE__
, ps3_result(result
));
249 ps3_disconnect_irq(virq
);
251 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
255 int ps3_send_event_locally(unsigned int virq
)
257 return lv1_send_event_locally(virq_to_hw(virq
));
261 * ps3_connect_event_irq - Assign a virq to a system bus device.
262 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
264 * @did: The HV device identifier read from the system repository.
265 * @interrupt_id: The device interrupt id read from the system repository.
266 * @virq: The assigned Linux virq.
268 * An event irq represents a virtual device interrupt. The interrupt_id
269 * coresponds to the software interrupt number.
272 int ps3_connect_event_irq(enum ps3_cpu_binding cpu
,
273 const struct ps3_device_id
*did
, unsigned int interrupt_id
,
278 result
= ps3_alloc_event_irq(cpu
, virq
);
283 result
= lv1_connect_interrupt_event_receive_port(did
->bus_id
,
284 did
->dev_id
, virq_to_hw(*virq
), interrupt_id
);
287 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
288 " failed: %s\n", __func__
, __LINE__
,
290 ps3_free_event_irq(*virq
);
295 pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
296 interrupt_id
, *virq
);
301 int ps3_disconnect_event_irq(const struct ps3_device_id
*did
,
302 unsigned int interrupt_id
, unsigned int virq
)
306 pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__
, __LINE__
,
309 result
= lv1_disconnect_interrupt_event_receive_port(did
->bus_id
,
310 did
->dev_id
, virq_to_hw(virq
), interrupt_id
);
313 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
314 " failed: %s\n", __func__
, __LINE__
,
317 ps3_free_event_irq(virq
);
319 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
324 * ps3_alloc_vuart_irq - Configure the system virtual uart virq.
325 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
327 * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
328 * @virq: The assigned Linux virq.
330 * The system supports only a single virtual uart, so multiple calls without
331 * freeing the interrupt will return a wrong state error.
334 int ps3_alloc_vuart_irq(enum ps3_cpu_binding cpu
, void* virt_addr_bmp
,
338 unsigned long outlet
;
341 BUG_ON(!is_kernel_addr((u64
)virt_addr_bmp
));
343 lpar_addr
= ps3_mm_phys_to_lpar(__pa(virt_addr_bmp
));
345 result
= lv1_configure_virtual_uart_irq(lpar_addr
, &outlet
);
348 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
349 __func__
, __LINE__
, ps3_result(result
));
353 result
= ps3_connect_irq(cpu
, outlet
, virq
);
359 int ps3_free_vuart_irq(unsigned int virq
)
363 result
= lv1_deconfigure_virtual_uart_irq();
366 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
367 __func__
, __LINE__
, ps3_result(result
));
371 ps3_disconnect_irq(virq
);
377 * ps3_alloc_spe_irq - Configure an spe virq.
378 * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
380 * @spe_id: The spe_id returned from lv1_construct_logical_spe().
381 * @class: The spe interrupt class {0,1,2}.
382 * @virq: The assigned Linux virq.
386 int ps3_alloc_spe_irq(enum ps3_cpu_binding cpu
, unsigned long spe_id
,
387 unsigned int class, unsigned int *virq
)
390 unsigned long outlet
;
394 result
= lv1_get_spe_irq_outlet(spe_id
, class, &outlet
);
397 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
398 __func__
, __LINE__
, ps3_result(result
));
402 result
= ps3_connect_irq(cpu
, outlet
, virq
);
408 int ps3_free_spe_irq(unsigned int virq
)
410 ps3_disconnect_irq(virq
);
414 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
415 #define PS3_PLUG_MAX 63
418 static void _dump_64_bmp(const char *header
, const u64
*p
, unsigned cpu
,
419 const char* func
, int line
)
421 pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
422 func
, line
, header
, cpu
,
423 *p
>> 48, (*p
>> 32) & 0xffff, (*p
>> 16) & 0xffff,
427 static void __attribute__ ((unused
)) _dump_256_bmp(const char *header
,
428 const u64
*p
, unsigned cpu
, const char* func
, int line
)
430 pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
431 func
, line
, header
, cpu
, p
[0], p
[1], p
[2], p
[3]);
434 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
435 static void _dump_bmp(struct ps3_private
* pd
, const char* func
, int line
)
439 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
440 _dump_64_bmp("stat", &pd
->bmp
.status
, pd
->cpu
, func
, line
);
441 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->cpu
, func
, line
);
442 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
445 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
446 static void __attribute__ ((unused
)) _dump_mask(struct ps3_private
* pd
,
447 const char* func
, int line
)
451 spin_lock_irqsave(&pd
->bmp
.lock
, flags
);
452 _dump_64_bmp("mask", &pd
->bmp
.mask
, pd
->cpu
, func
, line
);
453 spin_unlock_irqrestore(&pd
->bmp
.lock
, flags
);
456 static void dump_bmp(struct ps3_private
* pd
) {};
457 #endif /* defined(DEBUG) */
459 static void ps3_chip_mask(unsigned int virq
)
461 struct ps3_private
*pd
= get_irq_chip_data(virq
);
462 u64 bit
= 0x8000000000000000UL
>> virq
;
463 u64
*p
= &pd
->bmp
.mask
;
467 pr_debug("%s:%d: cpu %u, virq %d\n", __func__
, __LINE__
, pd
->cpu
, virq
);
469 local_irq_save(flags
);
475 : "=&r" (old
), "+m" (*p
)
479 lv1_did_update_interrupt_mask(pd
->node
, pd
->cpu
);
480 local_irq_restore(flags
);
483 static void ps3_chip_unmask(unsigned int virq
)
485 struct ps3_private
*pd
= get_irq_chip_data(virq
);
486 u64 bit
= 0x8000000000000000UL
>> virq
;
487 u64
*p
= &pd
->bmp
.mask
;
491 pr_debug("%s:%d: cpu %u, virq %d\n", __func__
, __LINE__
, pd
->cpu
, virq
);
493 local_irq_save(flags
);
499 : "=&r" (old
), "+m" (*p
)
503 lv1_did_update_interrupt_mask(pd
->node
, pd
->cpu
);
504 local_irq_restore(flags
);
507 static void ps3_chip_eoi(unsigned int virq
)
509 const struct ps3_private
*pd
= get_irq_chip_data(virq
);
510 lv1_end_of_interrupt_ext(pd
->node
, pd
->cpu
, virq
);
513 static struct irq_chip irq_chip
= {
515 .mask
= ps3_chip_mask
,
516 .unmask
= ps3_chip_unmask
,
520 static void ps3_host_unmap(struct irq_host
*h
, unsigned int virq
)
522 set_irq_chip_data(virq
, NULL
);
525 static int ps3_host_map(struct irq_host
*h
, unsigned int virq
,
526 irq_hw_number_t hwirq
)
528 pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__
, __LINE__
, hwirq
,
531 set_irq_chip_and_handler(virq
, &irq_chip
, handle_fasteoi_irq
);
536 static struct irq_host_ops ps3_host_ops
= {
538 .unmap
= ps3_host_unmap
,
541 void __init
ps3_register_ipi_debug_brk(unsigned int cpu
, unsigned int virq
)
543 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
545 pd
->bmp
.ipi_debug_brk_mask
= 0x8000000000000000UL
>> virq
;
547 pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__
, __LINE__
,
548 cpu
, virq
, pd
->bmp
.ipi_debug_brk_mask
);
551 unsigned int ps3_get_irq(void)
553 struct ps3_private
*pd
= &__get_cpu_var(ps3_private
);
554 u64 x
= (pd
->bmp
.status
& pd
->bmp
.mask
);
557 /* check for ipi break first to stop this cpu ASAP */
559 if (x
& pd
->bmp
.ipi_debug_brk_mask
)
560 x
&= pd
->bmp
.ipi_debug_brk_mask
;
562 asm volatile("cntlzd %0,%1" : "=r" (plug
) : "r" (x
));
565 if (unlikely(plug
) == NO_IRQ
) {
566 pr_debug("%s:%d: no plug found: cpu %u\n", __func__
, __LINE__
,
568 dump_bmp(&per_cpu(ps3_private
, 0));
569 dump_bmp(&per_cpu(ps3_private
, 1));
574 if (unlikely(plug
< NUM_ISA_INTERRUPTS
|| plug
> PS3_PLUG_MAX
)) {
575 dump_bmp(&per_cpu(ps3_private
, 0));
576 dump_bmp(&per_cpu(ps3_private
, 1));
583 void __init
ps3_init_IRQ(void)
587 struct irq_host
*host
;
589 host
= irq_alloc_host(IRQ_HOST_MAP_NOMAP
, 0, &ps3_host_ops
,
591 irq_set_default_host(host
);
592 irq_set_virq_count(PS3_PLUG_MAX
+ 1);
594 for_each_possible_cpu(cpu
) {
595 struct ps3_private
*pd
= &per_cpu(ps3_private
, cpu
);
597 lv1_get_logical_ppe_id(&pd
->node
);
598 pd
->cpu
= get_hard_smp_processor_id(cpu
);
599 spin_lock_init(&pd
->bmp
.lock
);
601 pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__
,
602 __LINE__
, pd
->node
, pd
->cpu
,
603 ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
605 result
= lv1_configure_irq_state_bitmap(pd
->node
, pd
->cpu
,
606 ps3_mm_phys_to_lpar(__pa(&pd
->bmp
)));
609 pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
610 " %s\n", __func__
, __LINE__
,
614 ppc_md
.get_irq
= ps3_get_irq
;