]>
Commit | Line | Data |
---|---|---|
2832a81d GL |
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> | |
2832a81d | 27 | #include <asm/lv1call.h> |
42d284bc | 28 | #include <asm/smp.h> |
2832a81d GL |
29 | |
30 | #include "platform.h" | |
31 | ||
32 | #if defined(DEBUG) | |
83bb643d | 33 | #define DBG udbg_printf |
2832a81d | 34 | #else |
83bb643d | 35 | #define DBG pr_debug |
2832a81d GL |
36 | #endif |
37 | ||
861be32c GL |
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 | * | |
b595076a | 47 | * The HV maintains per SMT thread mappings of HV outlet to HV plug on |
861be32c GL |
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(). | |
57715765 GL |
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. | |
861be32c GL |
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. | |
46ca0d15 SR |
63 | * |
64 | * The mask is declared as unsigned long so we can use set/clear_bit on it. | |
861be32c GL |
65 | */ |
66 | ||
57715765 GL |
67 | #define PS3_BMP_MINALIGN 64 |
68 | ||
861be32c GL |
69 | struct ps3_bmp { |
70 | struct { | |
71 | u64 status; | |
72 | u64 unused_1[3]; | |
46ca0d15 | 73 | unsigned long mask; |
861be32c GL |
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 | |
aab83500 GL |
83 | * @ppe_id: HV logical_ppe_id |
84 | * @thread_id: HV thread_id | |
861be32c GL |
85 | */ |
86 | ||
87 | struct ps3_private { | |
57715765 | 88 | struct ps3_bmp bmp __attribute__ ((aligned (PS3_BMP_MINALIGN))); |
aab83500 GL |
89 | u64 ppe_id; |
90 | u64 thread_id; | |
861be32c GL |
91 | }; |
92 | ||
93 | static DEFINE_PER_CPU(struct ps3_private, ps3_private); | |
94 | ||
743c1bb0 GL |
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); | |
743c1bb0 GL |
105 | unsigned long flags; |
106 | ||
5c949070 | 107 | pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__, |
aab83500 | 108 | pd->thread_id, virq); |
743c1bb0 GL |
109 | |
110 | local_irq_save(flags); | |
a354ab85 | 111 | clear_bit(63 - virq, &pd->bmp.mask); |
aab83500 | 112 | lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id); |
743c1bb0 GL |
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); | |
743c1bb0 GL |
126 | unsigned long flags; |
127 | ||
5c949070 | 128 | pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__, |
aab83500 | 129 | pd->thread_id, virq); |
743c1bb0 GL |
130 | |
131 | local_irq_save(flags); | |
a354ab85 | 132 | set_bit(63 - virq, &pd->bmp.mask); |
aab83500 | 133 | lv1_did_update_interrupt_mask(pd->ppe_id, pd->thread_id); |
743c1bb0 GL |
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); | |
aab83500 | 147 | lv1_end_of_interrupt_ext(pd->ppe_id, pd->thread_id, virq); |
743c1bb0 GL |
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 = { | |
b27df672 | 155 | .name = "ps3", |
743c1bb0 GL |
156 | .mask = ps3_chip_mask, |
157 | .unmask = ps3_chip_unmask, | |
158 | .eoi = ps3_chip_eoi, | |
159 | }; | |
160 | ||
dc4f60c2 GL |
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 | ||
fdedb4ca GU |
172 | static int ps3_virq_setup(enum ps3_cpu_binding cpu, unsigned long outlet, |
173 | unsigned int *virq) | |
861be32c GL |
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 | ||
861be32c GL |
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 | ||
9263e85a GL |
205 | ps3_chip_mask(*virq); |
206 | ||
861be32c GL |
207 | return result; |
208 | ||
209 | fail_set: | |
861be32c GL |
210 | irq_dispose_mapping(*virq); |
211 | fail_create: | |
212 | return result; | |
213 | } | |
214 | ||
dc4f60c2 GL |
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 | ||
fdedb4ca | 222 | static int ps3_virq_destroy(unsigned int virq) |
861be32c | 223 | { |
861be32c GL |
224 | const struct ps3_private *pd = get_irq_chip_data(virq); |
225 | ||
5c949070 | 226 | pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__, |
aab83500 | 227 | __LINE__, pd->ppe_id, pd->thread_id, virq); |
861be32c | 228 | |
861be32c GL |
229 | set_irq_chip_data(virq, NULL); |
230 | irq_dispose_mapping(virq); | |
dc4f60c2 GL |
231 | |
232 | pr_debug("%s:%d <-\n", __func__, __LINE__); | |
233 | return 0; | |
861be32c GL |
234 | } |
235 | ||
2832a81d | 236 | /** |
dc4f60c2 | 237 | * ps3_irq_plug_setup - Generic outlet and virq related setup. |
861be32c GL |
238 | * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be |
239 | * serviced on. | |
dc4f60c2 | 240 | * @outlet: The HV outlet from the various create outlet routines. |
2832a81d GL |
241 | * @virq: The assigned Linux virq. |
242 | * | |
dc4f60c2 | 243 | * Sets up virq and connects the irq plug. |
2832a81d GL |
244 | */ |
245 | ||
dc4f60c2 | 246 | int ps3_irq_plug_setup(enum ps3_cpu_binding cpu, unsigned long outlet, |
861be32c | 247 | unsigned int *virq) |
2832a81d GL |
248 | { |
249 | int result; | |
dc4f60c2 | 250 | struct ps3_private *pd; |
2832a81d | 251 | |
dc4f60c2 | 252 | result = ps3_virq_setup(cpu, outlet, virq); |
2832a81d GL |
253 | |
254 | if (result) { | |
dc4f60c2 GL |
255 | pr_debug("%s:%d: ps3_virq_setup failed\n", __func__, __LINE__); |
256 | goto fail_setup; | |
2832a81d GL |
257 | } |
258 | ||
dc4f60c2 GL |
259 | pd = get_irq_chip_data(*virq); |
260 | ||
261 | /* Binds outlet to cpu + virq. */ | |
262 | ||
aab83500 GL |
263 | result = lv1_connect_irq_plug_ext(pd->ppe_id, pd->thread_id, *virq, |
264 | outlet, 0); | |
2832a81d | 265 | |
dc4f60c2 GL |
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: | |
861be32c | 278 | return result; |
2832a81d | 279 | } |
dc4f60c2 GL |
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 | */ | |
2832a81d | 290 | |
dc4f60c2 | 291 | int ps3_irq_plug_destroy(unsigned int virq) |
2832a81d GL |
292 | { |
293 | int result; | |
dc4f60c2 | 294 | const struct ps3_private *pd = get_irq_chip_data(virq); |
2832a81d | 295 | |
5c949070 | 296 | pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__, |
aab83500 | 297 | __LINE__, pd->ppe_id, pd->thread_id, virq); |
dc4f60c2 | 298 | |
9263e85a GL |
299 | ps3_chip_mask(virq); |
300 | ||
aab83500 | 301 | result = lv1_disconnect_irq_plug_ext(pd->ppe_id, pd->thread_id, virq); |
2832a81d | 302 | |
ded84bcb | 303 | if (result) |
dc4f60c2 GL |
304 | pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n", |
305 | __func__, __LINE__, ps3_result(result)); | |
2832a81d | 306 | |
dc4f60c2 | 307 | ps3_virq_destroy(virq); |
2832a81d GL |
308 | |
309 | return result; | |
310 | } | |
dc4f60c2 | 311 | EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy); |
2832a81d GL |
312 | |
313 | /** | |
dc4f60c2 | 314 | * ps3_event_receive_port_setup - Setup an event receive port. |
861be32c GL |
315 | * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be |
316 | * serviced on. | |
2832a81d GL |
317 | * @virq: The assigned Linux virq. |
318 | * | |
319 | * The virq can be used with lv1_connect_interrupt_event_receive_port() to | |
dc4f60c2 GL |
320 | * arrange to receive interrupts from system-bus devices, or with |
321 | * ps3_send_event_locally() to signal events. | |
2832a81d GL |
322 | */ |
323 | ||
dc4f60c2 | 324 | int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu, unsigned int *virq) |
2832a81d GL |
325 | { |
326 | int result; | |
b17b3df1 | 327 | u64 outlet; |
2832a81d GL |
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 | ||
dc4f60c2 | 338 | result = ps3_irq_plug_setup(cpu, outlet, virq); |
861be32c | 339 | BUG_ON(result); |
2832a81d | 340 | |
861be32c | 341 | return result; |
2832a81d | 342 | } |
dc4f60c2 GL |
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 | */ | |
2832a81d | 353 | |
dc4f60c2 | 354 | int ps3_event_receive_port_destroy(unsigned int virq) |
2832a81d GL |
355 | { |
356 | int result; | |
357 | ||
9263e85a GL |
358 | pr_debug(" -> %s:%d virq %u\n", __func__, __LINE__, virq); |
359 | ||
360 | ps3_chip_mask(virq); | |
2832a81d GL |
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 | ||
9263e85a GL |
368 | /* |
369 | * Don't call ps3_virq_destroy() here since ps3_smp_cleanup_cpu() | |
370 | * calls from interrupt context (smp_call_function) when kexecing. | |
dc4f60c2 GL |
371 | */ |
372 | ||
2832a81d GL |
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 | /** | |
dc4f60c2 | 383 | * ps3_sb_event_receive_port_setup - Setup a system bus event receive port. |
861be32c GL |
384 | * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be |
385 | * serviced on. | |
6bb5cf10 | 386 | * @dev: The system bus device instance. |
2832a81d GL |
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 | ||
6bb5cf10 GL |
393 | int ps3_sb_event_receive_port_setup(struct ps3_system_bus_device *dev, |
394 | enum ps3_cpu_binding cpu, unsigned int *virq) | |
2832a81d | 395 | { |
dc4f60c2 GL |
396 | /* this should go in system-bus.c */ |
397 | ||
2832a81d GL |
398 | int result; |
399 | ||
dc4f60c2 | 400 | result = ps3_event_receive_port_setup(cpu, virq); |
2832a81d GL |
401 | |
402 | if (result) | |
403 | return result; | |
404 | ||
6bb5cf10 GL |
405 | result = lv1_connect_interrupt_event_receive_port(dev->bus_id, |
406 | dev->dev_id, virq_to_hw(*virq), dev->interrupt_id); | |
2832a81d GL |
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)); | |
dc4f60c2 | 412 | ps3_event_receive_port_destroy(*virq); |
2832a81d GL |
413 | *virq = NO_IRQ; |
414 | return result; | |
415 | } | |
416 | ||
417 | pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__, | |
6bb5cf10 | 418 | dev->interrupt_id, *virq); |
2832a81d GL |
419 | |
420 | return 0; | |
421 | } | |
dc4f60c2 | 422 | EXPORT_SYMBOL(ps3_sb_event_receive_port_setup); |
2832a81d | 423 | |
6bb5cf10 GL |
424 | int ps3_sb_event_receive_port_destroy(struct ps3_system_bus_device *dev, |
425 | unsigned int virq) | |
2832a81d | 426 | { |
dc4f60c2 GL |
427 | /* this should go in system-bus.c */ |
428 | ||
2832a81d GL |
429 | int result; |
430 | ||
431 | pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__, | |
6bb5cf10 | 432 | dev->interrupt_id, virq); |
2832a81d | 433 | |
6bb5cf10 GL |
434 | result = lv1_disconnect_interrupt_event_receive_port(dev->bus_id, |
435 | dev->dev_id, virq_to_hw(virq), dev->interrupt_id); | |
2832a81d GL |
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 | ||
dc4f60c2 GL |
442 | result = ps3_event_receive_port_destroy(virq); |
443 | BUG_ON(result); | |
2832a81d | 444 | |
9263e85a GL |
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 | ||
2832a81d GL |
453 | pr_debug(" <- %s:%d\n", __func__, __LINE__); |
454 | return result; | |
455 | } | |
dc4f60c2 | 456 | EXPORT_SYMBOL(ps3_sb_event_receive_port_destroy); |
2832a81d GL |
457 | |
458 | /** | |
dc4f60c2 GL |
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; | |
b17b3df1 | 473 | u64 outlet; |
dc4f60c2 GL |
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; | |
9263e85a | 493 | unsigned long outlet = virq_to_hw(virq); |
dc4f60c2 | 494 | |
9263e85a | 495 | ps3_chip_mask(virq); |
dc4f60c2 | 496 | |
9263e85a GL |
497 | /* |
498 | * lv1_destruct_io_irq_outlet() will destroy the IRQ plug, | |
499 | * so call ps3_irq_plug_destroy() first. | |
500 | */ | |
dc4f60c2 GL |
501 | |
502 | result = ps3_irq_plug_destroy(virq); | |
503 | BUG_ON(result); | |
504 | ||
9263e85a GL |
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 | ||
dc4f60c2 GL |
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. | |
861be32c GL |
517 | * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be |
518 | * serviced on. | |
2832a81d GL |
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 | ||
dc4f60c2 | 526 | int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu, void* virt_addr_bmp, |
861be32c | 527 | unsigned int *virq) |
2832a81d GL |
528 | { |
529 | int result; | |
b17b3df1 | 530 | u64 outlet; |
861be32c | 531 | u64 lpar_addr; |
2832a81d | 532 | |
861be32c | 533 | BUG_ON(!is_kernel_addr((u64)virt_addr_bmp)); |
2832a81d GL |
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 | ||
dc4f60c2 | 545 | result = ps3_irq_plug_setup(cpu, outlet, virq); |
861be32c | 546 | BUG_ON(result); |
2832a81d | 547 | |
861be32c | 548 | return result; |
2832a81d | 549 | } |
7626e78d | 550 | EXPORT_SYMBOL_GPL(ps3_vuart_irq_setup); |
2832a81d | 551 | |
dc4f60c2 | 552 | int ps3_vuart_irq_destroy(unsigned int virq) |
2832a81d GL |
553 | { |
554 | int result; | |
555 | ||
9263e85a | 556 | ps3_chip_mask(virq); |
2832a81d GL |
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 | ||
dc4f60c2 GL |
565 | result = ps3_irq_plug_destroy(virq); |
566 | BUG_ON(result); | |
2832a81d GL |
567 | |
568 | return result; | |
569 | } | |
7626e78d | 570 | EXPORT_SYMBOL_GPL(ps3_vuart_irq_destroy); |
2832a81d GL |
571 | |
572 | /** | |
dc4f60c2 | 573 | * ps3_spe_irq_setup - Setup an spe virq. |
861be32c GL |
574 | * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be |
575 | * serviced on. | |
2832a81d GL |
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 | ||
dc4f60c2 | 582 | int ps3_spe_irq_setup(enum ps3_cpu_binding cpu, unsigned long spe_id, |
861be32c | 583 | unsigned int class, unsigned int *virq) |
2832a81d GL |
584 | { |
585 | int result; | |
b17b3df1 | 586 | u64 outlet; |
2832a81d GL |
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 | ||
dc4f60c2 | 598 | result = ps3_irq_plug_setup(cpu, outlet, virq); |
861be32c | 599 | BUG_ON(result); |
2832a81d | 600 | |
861be32c | 601 | return result; |
2832a81d GL |
602 | } |
603 | ||
dc4f60c2 | 604 | int ps3_spe_irq_destroy(unsigned int virq) |
2832a81d | 605 | { |
9263e85a GL |
606 | int result; |
607 | ||
608 | ps3_chip_mask(virq); | |
609 | ||
610 | result = ps3_irq_plug_destroy(virq); | |
dc4f60c2 | 611 | BUG_ON(result); |
9263e85a GL |
612 | |
613 | return result; | |
2832a81d GL |
614 | } |
615 | ||
b1eeb38e | 616 | |
2832a81d GL |
617 | #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1) |
618 | #define PS3_PLUG_MAX 63 | |
619 | ||
2832a81d | 620 | #if defined(DEBUG) |
861be32c | 621 | static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu, |
2832a81d GL |
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 | ||
848cfdc5 | 630 | static void __maybe_unused _dump_256_bmp(const char *header, |
861be32c | 631 | const u64 *p, unsigned cpu, const char* func, int line) |
2832a81d GL |
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__) | |
9633ac8d | 638 | static void _dump_bmp(struct ps3_private* pd, const char* func, int line) |
2832a81d GL |
639 | { |
640 | unsigned long flags; | |
641 | ||
642 | spin_lock_irqsave(&pd->bmp.lock, flags); | |
aab83500 GL |
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); | |
2832a81d GL |
645 | spin_unlock_irqrestore(&pd->bmp.lock, flags); |
646 | } | |
647 | ||
648 | #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__) | |
848cfdc5 | 649 | static void __maybe_unused _dump_mask(struct ps3_private *pd, |
2832a81d GL |
650 | const char* func, int line) |
651 | { | |
652 | unsigned long flags; | |
653 | ||
654 | spin_lock_irqsave(&pd->bmp.lock, flags); | |
aab83500 | 655 | _dump_64_bmp("mask", &pd->bmp.mask, pd->thread_id, func, line); |
2832a81d GL |
656 | spin_unlock_irqrestore(&pd->bmp.lock, flags); |
657 | } | |
658 | #else | |
9633ac8d | 659 | static void dump_bmp(struct ps3_private* pd) {}; |
2832a81d GL |
660 | #endif /* defined(DEBUG) */ |
661 | ||
9633ac8d | 662 | static void ps3_host_unmap(struct irq_host *h, unsigned int virq) |
2832a81d | 663 | { |
861be32c | 664 | set_irq_chip_data(virq, NULL); |
2832a81d GL |
665 | } |
666 | ||
9633ac8d | 667 | static int ps3_host_map(struct irq_host *h, unsigned int virq, |
2832a81d GL |
668 | irq_hw_number_t hwirq) |
669 | { | |
861be32c GL |
670 | pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq, |
671 | virq); | |
2832a81d | 672 | |
9263e85a | 673 | set_irq_chip_and_handler(virq, &ps3_irq_chip, handle_fasteoi_irq); |
2832a81d | 674 | |
861be32c | 675 | return 0; |
2832a81d GL |
676 | } |
677 | ||
8528ab84 ME |
678 | static int ps3_host_match(struct irq_host *h, struct device_node *np) |
679 | { | |
680 | /* Match all */ | |
681 | return 1; | |
682 | } | |
683 | ||
9633ac8d GL |
684 | static struct irq_host_ops ps3_host_ops = { |
685 | .map = ps3_host_map, | |
686 | .unmap = ps3_host_unmap, | |
8528ab84 | 687 | .match = ps3_host_match, |
2832a81d GL |
688 | }; |
689 | ||
690 | void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq) | |
691 | { | |
9633ac8d | 692 | struct ps3_private *pd = &per_cpu(ps3_private, cpu); |
2832a81d GL |
693 | |
694 | pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq; | |
695 | ||
5c949070 | 696 | pr_debug("%s:%d: cpu %u, virq %u, mask %llxh\n", __func__, __LINE__, |
2832a81d GL |
697 | cpu, virq, pd->bmp.ipi_debug_brk_mask); |
698 | } | |
699 | ||
9263e85a | 700 | static unsigned int ps3_get_irq(void) |
2832a81d | 701 | { |
9cf9e196 | 702 | struct ps3_private *pd = &__get_cpu_var(ps3_private); |
861be32c | 703 | u64 x = (pd->bmp.status & pd->bmp.mask); |
9cf9e196 | 704 | unsigned int plug; |
2832a81d GL |
705 | |
706 | /* check for ipi break first to stop this cpu ASAP */ | |
707 | ||
9cf9e196 BH |
708 | if (x & pd->bmp.ipi_debug_brk_mask) |
709 | x &= pd->bmp.ipi_debug_brk_mask; | |
2832a81d | 710 | |
9cf9e196 BH |
711 | asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x)); |
712 | plug &= 0x3f; | |
2832a81d | 713 | |
ad18c3db | 714 | if (unlikely(plug == NO_IRQ)) { |
5c949070 | 715 | pr_debug("%s:%d: no plug found: thread_id %llu\n", __func__, |
aab83500 | 716 | __LINE__, pd->thread_id); |
9633ac8d GL |
717 | dump_bmp(&per_cpu(ps3_private, 0)); |
718 | dump_bmp(&per_cpu(ps3_private, 1)); | |
2832a81d GL |
719 | return NO_IRQ; |
720 | } | |
721 | ||
722 | #if defined(DEBUG) | |
9cf9e196 | 723 | if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) { |
9633ac8d GL |
724 | dump_bmp(&per_cpu(ps3_private, 0)); |
725 | dump_bmp(&per_cpu(ps3_private, 1)); | |
2832a81d GL |
726 | BUG(); |
727 | } | |
728 | #endif | |
729 | return plug; | |
730 | } | |
731 | ||
732 | void __init ps3_init_IRQ(void) | |
733 | { | |
734 | int result; | |
2832a81d GL |
735 | unsigned cpu; |
736 | struct irq_host *host; | |
737 | ||
52964f87 | 738 | host = irq_alloc_host(NULL, IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops, |
2832a81d GL |
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) { | |
9633ac8d | 744 | struct ps3_private *pd = &per_cpu(ps3_private, cpu); |
2832a81d | 745 | |
aab83500 GL |
746 | lv1_get_logical_ppe_id(&pd->ppe_id); |
747 | pd->thread_id = get_hard_smp_processor_id(cpu); | |
2832a81d GL |
748 | spin_lock_init(&pd->bmp.lock); |
749 | ||
5c949070 | 750 | pr_debug("%s:%d: ppe_id %llu, thread_id %llu, bmp %lxh\n", |
aab83500 | 751 | __func__, __LINE__, pd->ppe_id, pd->thread_id, |
407e24a0 GL |
752 | ps3_mm_phys_to_lpar(__pa(&pd->bmp))); |
753 | ||
aab83500 GL |
754 | result = lv1_configure_irq_state_bitmap(pd->ppe_id, |
755 | pd->thread_id, ps3_mm_phys_to_lpar(__pa(&pd->bmp))); | |
2832a81d GL |
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 | } | |
9263e85a GL |
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 | ||
5c949070 | 775 | DBG("%s:%d: lv1_configure_irq_state_bitmap (%llu:%llu/%d) %s\n", __func__, |
9263e85a GL |
776 | __LINE__, ppe_id, thread_id, cpu, ps3_result(result)); |
777 | } |