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