d3c97fbff7ef6263f35c4985ba370232d6cc0fcc
[linux-2.6.git] / arch / powerpc / platforms / ps3 / interrupt.c
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/ps3.h>
28 #include <asm/lv1call.h>
29
30 #include "platform.h"
31
32 #if defined(DEBUG)
33 #define DBG(fmt...) udbg_printf(fmt)
34 #else
35 #define DBG(fmt...) do{if(0)printk(fmt);}while(0)
36 #endif
37
38 /**
39  * ps3_alloc_io_irq - Assign a virq to a system bus device.
40  * interrupt_id: The device interrupt id read from the system repository.
41  * @virq: The assigned Linux virq.
42  *
43  * An io irq represents a non-virtualized device interrupt.  interrupt_id
44  * coresponds to the interrupt number of the interrupt controller.
45  */
46
47 int ps3_alloc_io_irq(unsigned int interrupt_id, unsigned int *virq)
48 {
49         int result;
50         unsigned long outlet;
51
52         result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
53
54         if (result) {
55                 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
56                         __func__, __LINE__, ps3_result(result));
57                 return result;
58         }
59
60         *virq = irq_create_mapping(NULL, outlet);
61
62         pr_debug("%s:%d: interrupt_id %u => outlet %lu, virq %u\n",
63                 __func__, __LINE__, interrupt_id, outlet, *virq);
64
65         return 0;
66 }
67
68 int ps3_free_io_irq(unsigned int virq)
69 {
70         int result;
71
72         result = lv1_destruct_io_irq_outlet(virq_to_hw(virq));
73
74         if (result)
75                 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
76                         __func__, __LINE__, ps3_result(result));
77
78         irq_dispose_mapping(virq);
79
80         return result;
81 }
82
83 /**
84  * ps3_alloc_event_irq - Allocate a virq for use with a system event.
85  * @virq: The assigned Linux virq.
86  *
87  * The virq can be used with lv1_connect_interrupt_event_receive_port() to
88  * arrange to receive events, or with ps3_send_event_locally() to signal
89  * events.
90  */
91
92 int ps3_alloc_event_irq(unsigned int *virq)
93 {
94         int result;
95         unsigned long outlet;
96
97         result = lv1_construct_event_receive_port(&outlet);
98
99         if (result) {
100                 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
101                         __func__, __LINE__, ps3_result(result));
102                 *virq = NO_IRQ;
103                 return result;
104         }
105
106         *virq = irq_create_mapping(NULL, outlet);
107
108         pr_debug("%s:%d: outlet %lu, virq %u\n", __func__, __LINE__, outlet,
109                 *virq);
110
111         return 0;
112 }
113
114 int ps3_free_event_irq(unsigned int virq)
115 {
116         int result;
117
118         pr_debug(" -> %s:%d\n", __func__, __LINE__);
119
120         result = lv1_destruct_event_receive_port(virq_to_hw(virq));
121
122         if (result)
123                 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
124                         __func__, __LINE__, ps3_result(result));
125
126         irq_dispose_mapping(virq);
127
128         pr_debug(" <- %s:%d\n", __func__, __LINE__);
129         return result;
130 }
131
132 int ps3_send_event_locally(unsigned int virq)
133 {
134         return lv1_send_event_locally(virq_to_hw(virq));
135 }
136
137 /**
138  * ps3_connect_event_irq - Assign a virq to a system bus device.
139  * @did: The HV device identifier read from the system repository.
140  * @interrupt_id: The device interrupt id read from the system repository.
141  * @virq: The assigned Linux virq.
142  *
143  * An event irq represents a virtual device interrupt.  The interrupt_id
144  * coresponds to the software interrupt number.
145  */
146
147 int ps3_connect_event_irq(const struct ps3_device_id *did,
148         unsigned int interrupt_id, unsigned int *virq)
149 {
150         int result;
151
152         result = ps3_alloc_event_irq(virq);
153
154         if (result)
155                 return result;
156
157         result = lv1_connect_interrupt_event_receive_port(did->bus_id,
158                 did->dev_id, virq_to_hw(*virq), interrupt_id);
159
160         if (result) {
161                 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
162                         " failed: %s\n", __func__, __LINE__,
163                         ps3_result(result));
164                 ps3_free_event_irq(*virq);
165                 *virq = NO_IRQ;
166                 return result;
167         }
168
169         pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
170                 interrupt_id, *virq);
171
172         return 0;
173 }
174
175 int ps3_disconnect_event_irq(const struct ps3_device_id *did,
176         unsigned int interrupt_id, unsigned int virq)
177 {
178         int result;
179
180         pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
181                 interrupt_id, virq);
182
183         result = lv1_disconnect_interrupt_event_receive_port(did->bus_id,
184                 did->dev_id, virq_to_hw(virq), interrupt_id);
185
186         if (result)
187                 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
188                         " failed: %s\n", __func__, __LINE__,
189                         ps3_result(result));
190
191         ps3_free_event_irq(virq);
192
193         pr_debug(" <- %s:%d\n", __func__, __LINE__);
194         return result;
195 }
196
197 /**
198  * ps3_alloc_vuart_irq - Configure the system virtual uart virq.
199  * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
200  * @virq: The assigned Linux virq.
201  *
202  * The system supports only a single virtual uart, so multiple calls without
203  * freeing the interrupt will return a wrong state error.
204  */
205
206 int ps3_alloc_vuart_irq(void* virt_addr_bmp, unsigned int *virq)
207 {
208         int result;
209         unsigned long outlet;
210         unsigned long lpar_addr;
211
212         BUG_ON(!is_kernel_addr((unsigned long)virt_addr_bmp));
213
214         lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));
215
216         result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);
217
218         if (result) {
219                 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
220                         __func__, __LINE__, ps3_result(result));
221                 return result;
222         }
223
224         *virq = irq_create_mapping(NULL, outlet);
225
226         pr_debug("%s:%d: outlet %lu, virq %u\n", __func__, __LINE__,
227                 outlet, *virq);
228
229         return 0;
230 }
231
232 int ps3_free_vuart_irq(unsigned int virq)
233 {
234         int result;
235
236         result = lv1_deconfigure_virtual_uart_irq();
237
238         if (result) {
239                 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
240                         __func__, __LINE__, ps3_result(result));
241                 return result;
242         }
243
244         irq_dispose_mapping(virq);
245
246         return result;
247 }
248
249 /**
250  * ps3_alloc_spe_irq - Configure an spe virq.
251  * @spe_id: The spe_id returned from lv1_construct_logical_spe().
252  * @class: The spe interrupt class {0,1,2}.
253  * @virq: The assigned Linux virq.
254  *
255  */
256
257 int ps3_alloc_spe_irq(unsigned long spe_id, unsigned int class,
258         unsigned int *virq)
259 {
260         int result;
261         unsigned long outlet;
262
263         BUG_ON(class > 2);
264
265         result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);
266
267         if (result) {
268                 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
269                         __func__, __LINE__, ps3_result(result));
270                 return result;
271         }
272
273         *virq = irq_create_mapping(NULL, outlet);
274
275         pr_debug("%s:%d: spe_id %lu, class %u, outlet %lu, virq %u\n",
276                 __func__, __LINE__, spe_id, class, outlet, *virq);
277
278         return 0;
279 }
280
281 int ps3_free_spe_irq(unsigned int virq)
282 {
283         irq_dispose_mapping(virq);
284         return 0;
285 }
286
287 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
288 #define PS3_PLUG_MAX 63
289
290 /**
291  * struct ps3_bmp - a per cpu irq status and mask bitmap structure
292  * @status: 256 bit status bitmap indexed by plug
293  * @unused_1:
294  * @mask: 256 bit mask bitmap indexed by plug
295  * @unused_2:
296  * @lock:
297  * @ipi_debug_brk_mask:
298  *
299  * The HV mantains per SMT thread mappings of HV outlet to HV plug on
300  * behalf of the guest.  These mappings are implemented as 256 bit guest
301  * supplied bitmaps indexed by plug number.  The address of the bitmaps are
302  * registered with the HV through lv1_configure_irq_state_bitmap().
303  *
304  * The HV supports 256 plugs per thread, assigned as {0..255}, for a total
305  * of 512 plugs supported on a processor.  To simplify the logic this
306  * implementation equates HV plug value to linux virq value, constrains each
307  * interrupt to have a system wide unique plug number, and limits the range
308  * of the plug values to map into the first dword of the bitmaps.  This
309  * gives a usable range of plug values of  {NUM_ISA_INTERRUPTS..63}.  Note
310  * that there is no constraint on how many in this set an individual thread
311  * can aquire.
312  */
313
314 struct ps3_bmp {
315         struct {
316                 unsigned long status;
317                 unsigned long unused_1[3];
318                 unsigned long mask;
319                 unsigned long unused_2[3];
320         } __attribute__ ((aligned (64)));
321
322         spinlock_t lock;
323         unsigned long ipi_debug_brk_mask;
324 };
325
326 /**
327  * struct ps3_private - a per cpu data structure
328  * @bmp: ps3_bmp structure
329  * @node: HV logical_ppe_id
330  * @cpu: HV thread_id
331  */
332
333 struct ps3_private {
334         struct ps3_bmp bmp;
335         unsigned long node;
336         unsigned int cpu;
337 };
338
339 #if defined(DEBUG)
340 static void _dump_64_bmp(const char *header, const unsigned long *p, unsigned cpu,
341         const char* func, int line)
342 {
343         pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
344                 func, line, header, cpu,
345                 *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
346                 *p & 0xffff);
347 }
348
349 static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
350         const unsigned long *p, unsigned cpu, const char* func, int line)
351 {
352         pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
353                 func, line, header, cpu, p[0], p[1], p[2], p[3]);
354 }
355
356 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
357 static void _dump_bmp(struct ps3_private* pd, const char* func, int line)
358 {
359         unsigned long flags;
360
361         spin_lock_irqsave(&pd->bmp.lock, flags);
362         _dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
363         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
364         spin_unlock_irqrestore(&pd->bmp.lock, flags);
365 }
366
367 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
368 static void __attribute__ ((unused)) _dump_mask(struct ps3_private* pd,
369         const char* func, int line)
370 {
371         unsigned long flags;
372
373         spin_lock_irqsave(&pd->bmp.lock, flags);
374         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
375         spin_unlock_irqrestore(&pd->bmp.lock, flags);
376 }
377 #else
378 static void dump_bmp(struct ps3_private* pd) {};
379 #endif /* defined(DEBUG) */
380
381 static void ps3_chip_mask(unsigned int virq)
382 {
383         struct ps3_private *pd = get_irq_chip_data(virq);
384         unsigned long bit = 0x8000000000000000UL >> virq;
385         unsigned long *p = &pd->bmp.mask;
386         unsigned long old;
387         unsigned long flags;
388
389         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
390
391         local_irq_save(flags);
392         asm volatile(
393                      "1:        ldarx %0,0,%3\n"
394                      "andc      %0,%0,%2\n"
395                      "stdcx.    %0,0,%3\n"
396                      "bne-      1b"
397                      : "=&r" (old), "+m" (*p)
398                      : "r" (bit), "r" (p)
399                      : "cc" );
400
401         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
402         local_irq_restore(flags);
403 }
404
405 static void ps3_chip_unmask(unsigned int virq)
406 {
407         struct ps3_private *pd = get_irq_chip_data(virq);
408         unsigned long bit = 0x8000000000000000UL >> virq;
409         unsigned long *p = &pd->bmp.mask;
410         unsigned long old;
411         unsigned long flags;
412
413         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
414
415         local_irq_save(flags);
416         asm volatile(
417                      "1:        ldarx %0,0,%3\n"
418                      "or        %0,%0,%2\n"
419                      "stdcx.    %0,0,%3\n"
420                      "bne-      1b"
421                      : "=&r" (old), "+m" (*p)
422                      : "r" (bit), "r" (p)
423                      : "cc" );
424
425         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
426         local_irq_restore(flags);
427 }
428
429 static void ps3_chip_eoi(unsigned int virq)
430 {
431         const struct ps3_private *pd = get_irq_chip_data(virq);
432         lv1_end_of_interrupt_ext(pd->node, pd->cpu, virq);
433 }
434
435 static struct irq_chip irq_chip = {
436         .typename = "ps3",
437         .mask = ps3_chip_mask,
438         .unmask = ps3_chip_unmask,
439         .eoi = ps3_chip_eoi,
440 };
441
442 static void ps3_host_unmap(struct irq_host *h, unsigned int virq)
443 {
444         int result;
445         const struct ps3_private *pd = get_irq_chip_data(virq);
446
447         pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__,
448                 pd->node, pd->cpu, virq);
449
450         lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, virq);
451
452         result = set_irq_chip_data(virq, NULL);
453         BUG_ON(result);
454 }
455
456 static DEFINE_PER_CPU(struct ps3_private, ps3_private);
457
458 static int ps3_host_map(struct irq_host *h, unsigned int virq,
459         irq_hw_number_t hwirq)
460 {
461         int result;
462         struct ps3_private *pd = &__get_cpu_var(ps3_private);
463
464         pr_debug("%s:%d: node %lu, cpu %d, hwirq %lu => virq %u\n", __func__,
465                 __LINE__, pd->node, pd->cpu, hwirq, virq);
466
467         /* Binds this virq to pd->cpu (current cpu) */
468
469         result = lv1_connect_irq_plug_ext(pd->node, pd->cpu, virq, hwirq, 0);
470
471         if (result) {
472                 pr_info("%s:%d: lv1_connect_irq_plug_ext failed:"
473                         " %s\n", __func__, __LINE__, ps3_result(result));
474                 return -EPERM;
475         }
476
477         result = set_irq_chip_data(virq, pd);
478         BUG_ON(result);
479
480         set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);
481
482         return result;
483 }
484
485 static struct irq_host_ops ps3_host_ops = {
486         .map = ps3_host_map,
487         .unmap = ps3_host_unmap,
488 };
489
490 void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
491 {
492         struct ps3_private *pd = &per_cpu(ps3_private, cpu);
493
494         pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
495
496         pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
497                 cpu, virq, pd->bmp.ipi_debug_brk_mask);
498 }
499
500 unsigned int ps3_get_irq(void)
501 {
502         struct ps3_private *pd = &__get_cpu_var(ps3_private);
503         unsigned long x = (pd->bmp.status & pd->bmp.mask);
504         unsigned int plug;
505
506         /* check for ipi break first to stop this cpu ASAP */
507
508         if (x & pd->bmp.ipi_debug_brk_mask)
509                 x &= pd->bmp.ipi_debug_brk_mask;
510
511         asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x));
512         plug &= 0x3f;
513
514         if (unlikely(plug) == NO_IRQ) {
515                 pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
516                         pd->cpu);
517                 dump_bmp(&per_cpu(ps3_private, 0));
518                 dump_bmp(&per_cpu(ps3_private, 1));
519                 return NO_IRQ;
520         }
521
522 #if defined(DEBUG)
523         if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) {
524                 dump_bmp(&per_cpu(ps3_private, 0));
525                 dump_bmp(&per_cpu(ps3_private, 1));
526                 BUG();
527         }
528 #endif
529         return plug;
530 }
531
532 void __init ps3_init_IRQ(void)
533 {
534         int result;
535         unsigned cpu;
536         struct irq_host *host;
537
538         host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops,
539                 PS3_INVALID_OUTLET);
540         irq_set_default_host(host);
541         irq_set_virq_count(PS3_PLUG_MAX + 1);
542
543         for_each_possible_cpu(cpu) {
544                 struct ps3_private *pd = &per_cpu(ps3_private, cpu);
545
546                 lv1_get_logical_ppe_id(&pd->node);
547                 pd->cpu = get_hard_smp_processor_id(cpu);
548                 spin_lock_init(&pd->bmp.lock);
549
550                 pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__,
551                         __LINE__, pd->node, pd->cpu,
552                         ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
553
554                 result = lv1_configure_irq_state_bitmap(pd->node, pd->cpu,
555                         ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
556
557                 if (result)
558                         pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
559                                 " %s\n", __func__, __LINE__,
560                                 ps3_result(result));
561         }
562
563         ppc_md.get_irq = ps3_get_irq;
564 }