[POWERPC] ps3: add interrupt support
[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 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 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__ ((packed));
321         spinlock_t lock;
322         unsigned long ipi_debug_brk_mask;
323 };
324
325 /**
326  * struct private - a per cpu data structure
327  * @node: HV node id
328  * @cpu: HV thread id
329  * @bmp: an HV bmp structure
330  */
331
332 struct private {
333         unsigned long node;
334         unsigned int cpu;
335         struct bmp bmp;
336 };
337
338 #if defined(DEBUG)
339 static void _dump_64_bmp(const char *header, const unsigned long *p, unsigned cpu,
340         const char* func, int line)
341 {
342         pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
343                 func, line, header, cpu,
344                 *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
345                 *p & 0xffff);
346 }
347
348 static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
349         const unsigned long *p, unsigned cpu, const char* func, int line)
350 {
351         pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
352                 func, line, header, cpu, p[0], p[1], p[2], p[3]);
353 }
354
355 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
356 static void _dump_bmp(struct private* pd, const char* func, int line)
357 {
358         unsigned long flags;
359
360         spin_lock_irqsave(&pd->bmp.lock, flags);
361         _dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
362         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
363         spin_unlock_irqrestore(&pd->bmp.lock, flags);
364 }
365
366 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
367 static void __attribute__ ((unused)) _dump_mask(struct private* pd,
368         const char* func, int line)
369 {
370         unsigned long flags;
371
372         spin_lock_irqsave(&pd->bmp.lock, flags);
373         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
374         spin_unlock_irqrestore(&pd->bmp.lock, flags);
375 }
376 #else
377 static void dump_bmp(struct private* pd) {};
378 #endif /* defined(DEBUG) */
379
380 static void chip_mask(unsigned int virq)
381 {
382         unsigned long flags;
383         struct private *pd = get_irq_chip_data(virq);
384
385         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
386
387         BUG_ON(virq < NUM_ISA_INTERRUPTS);
388         BUG_ON(virq > PS3_PLUG_MAX);
389
390         spin_lock_irqsave(&pd->bmp.lock, flags);
391         pd->bmp.mask &= ~(0x8000000000000000UL >> virq);
392         spin_unlock_irqrestore(&pd->bmp.lock, flags);
393
394         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
395 }
396
397 static void chip_unmask(unsigned int virq)
398 {
399         unsigned long flags;
400         struct private *pd = get_irq_chip_data(virq);
401
402         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
403
404         BUG_ON(virq < NUM_ISA_INTERRUPTS);
405         BUG_ON(virq > PS3_PLUG_MAX);
406
407         spin_lock_irqsave(&pd->bmp.lock, flags);
408         pd->bmp.mask |= (0x8000000000000000UL >> virq);
409         spin_unlock_irqrestore(&pd->bmp.lock, flags);
410
411         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
412 }
413
414 static void chip_eoi(unsigned int virq)
415 {
416         lv1_end_of_interrupt(virq);
417 }
418
419 static struct irq_chip irq_chip = {
420         .typename = "ps3",
421         .mask = chip_mask,
422         .unmask = chip_unmask,
423         .eoi = chip_eoi,
424 };
425
426 static void host_unmap(struct irq_host *h, unsigned int virq)
427 {
428         int result;
429
430         pr_debug("%s:%d: virq %d\n", __func__, __LINE__, virq);
431
432         lv1_disconnect_irq_plug(virq);
433
434         result = set_irq_chip_data(virq, NULL);
435         BUG_ON(result);
436 }
437
438 static DEFINE_PER_CPU(struct private, private);
439
440 static int host_map(struct irq_host *h, unsigned int virq,
441         irq_hw_number_t hwirq)
442 {
443         int result;
444         unsigned int cpu;
445
446         pr_debug(" -> %s:%d\n", __func__, __LINE__);
447         pr_debug("%s:%d: hwirq %lu => virq %u\n", __func__, __LINE__, hwirq,
448                 virq);
449
450         /* bind this virq to a cpu */
451
452         preempt_disable();
453         cpu = smp_processor_id();
454         result = lv1_connect_irq_plug(virq, hwirq);
455         preempt_enable();
456
457         if (result) {
458                 pr_info("%s:%d: lv1_connect_irq_plug failed:"
459                         " %s\n", __func__, __LINE__, ps3_result(result));
460                 return -EPERM;
461         }
462
463         result = set_irq_chip_data(virq, &per_cpu(private, cpu));
464         BUG_ON(result);
465
466         set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);
467
468         pr_debug(" <- %s:%d\n", __func__, __LINE__);
469         return result;
470 }
471
472 static struct irq_host_ops host_ops = {
473         .map = host_map,
474         .unmap = host_unmap,
475 };
476
477 void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
478 {
479         struct private *pd = &per_cpu(private, cpu);
480
481         pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
482
483         pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
484                 cpu, virq, pd->bmp.ipi_debug_brk_mask);
485 }
486
487 static int bmp_get_and_clear_status_bit(struct bmp *m)
488 {
489         unsigned long flags;
490         unsigned int bit;
491         unsigned long x;
492
493         spin_lock_irqsave(&m->lock, flags);
494
495         /* check for ipi break first to stop this cpu ASAP */
496
497         if (m->status & m->ipi_debug_brk_mask) {
498                 m->status &= ~m->ipi_debug_brk_mask;
499                 spin_unlock_irqrestore(&m->lock, flags);
500                 return __ilog2(m->ipi_debug_brk_mask);
501         }
502
503         x = (m->status & m->mask);
504
505         for (bit = NUM_ISA_INTERRUPTS, x <<= bit; x; bit++, x <<= 1)
506                 if (x & 0x8000000000000000UL) {
507                         m->status &= ~(0x8000000000000000UL >> bit);
508                         spin_unlock_irqrestore(&m->lock, flags);
509                         return bit;
510                 }
511
512         spin_unlock_irqrestore(&m->lock, flags);
513
514         pr_debug("%s:%d: not found\n", __func__, __LINE__);
515         return -1;
516 }
517
518 unsigned int ps3_get_irq(void)
519 {
520         int plug;
521
522         struct private *pd = &__get_cpu_var(private);
523
524         plug = bmp_get_and_clear_status_bit(&pd->bmp);
525
526         if (plug < 1) {
527                 pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
528                         pd->cpu);
529                 dump_bmp(&per_cpu(private, 0));
530                 dump_bmp(&per_cpu(private, 1));
531                 return NO_IRQ;
532         }
533
534 #if defined(DEBUG)
535         if (plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX) {
536                 dump_bmp(&per_cpu(private, 0));
537                 dump_bmp(&per_cpu(private, 1));
538                 BUG();
539         }
540 #endif
541         return plug;
542 }
543
544 void __init ps3_init_IRQ(void)
545 {
546         int result;
547         unsigned long node;
548         unsigned cpu;
549         struct irq_host *host;
550
551         lv1_get_logical_ppe_id(&node);
552
553         host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &host_ops,
554                 PS3_INVALID_OUTLET);
555         irq_set_default_host(host);
556         irq_set_virq_count(PS3_PLUG_MAX + 1);
557
558         for_each_possible_cpu(cpu) {
559                 struct private *pd = &per_cpu(private, cpu);
560
561                 pd->node = node;
562                 pd->cpu = cpu;
563                 spin_lock_init(&pd->bmp.lock);
564
565                 result = lv1_configure_irq_state_bitmap(node, cpu,
566                         ps3_mm_phys_to_lpar(__pa(&pd->bmp.status)));
567
568                 if (result)
569                         pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
570                                 " %s\n", __func__, __LINE__,
571                                 ps3_result(result));
572         }
573
574         ppc_md.get_irq = ps3_get_irq;
575 }