← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to arch/powerpc/platforms/ps3/interrupt.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/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
}