861be32ce7
Change the PS3 irq allocation routines to take an argument indicating which cpu (processor thread) the interrupt should be serviced on. The current system configuration favors device interrupts that are serviced on cpu0, so that is used as the default. Signed-off-by: Geoff Levand <geoffrey.levand@am.sony.com> Acked-by: Arnd Bergmann <arnd.bergmann@de.ibm.com> Signed-off-by: Paul Mackerras <paulus@samba.org>
616 lines
15 KiB
C
616 lines
15 KiB
C
/*
|
|
* PS3 interrupt routines.
|
|
*
|
|
* Copyright (C) 2006 Sony Computer Entertainment Inc.
|
|
* Copyright 2006 Sony Corp.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/irq.h>
|
|
|
|
#include <asm/machdep.h>
|
|
#include <asm/udbg.h>
|
|
#include <asm/ps3.h>
|
|
#include <asm/lv1call.h>
|
|
|
|
#include "platform.h"
|
|
|
|
#if defined(DEBUG)
|
|
#define DBG(fmt...) udbg_printf(fmt)
|
|
#else
|
|
#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
|
|
#endif
|
|
|
|
/**
|
|
* struct ps3_bmp - a per cpu irq status and mask bitmap structure
|
|
* @status: 256 bit status bitmap indexed by plug
|
|
* @unused_1:
|
|
* @mask: 256 bit mask bitmap indexed by plug
|
|
* @unused_2:
|
|
* @lock:
|
|
* @ipi_debug_brk_mask:
|
|
*
|
|
* The HV mantains per SMT thread mappings of HV outlet to HV plug on
|
|
* behalf of the guest. These mappings are implemented as 256 bit guest
|
|
* supplied bitmaps indexed by plug number. The addresses of the bitmaps
|
|
* are registered with the HV through lv1_configure_irq_state_bitmap().
|
|
*
|
|
* The HV supports 256 plugs per thread, assigned as {0..255}, for a total
|
|
* of 512 plugs supported on a processor. To simplify the logic this
|
|
* implementation equates HV plug value to Linux virq value, constrains each
|
|
* interrupt to have a system wide unique plug number, and limits the range
|
|
* of the plug values to map into the first dword of the bitmaps. This
|
|
* gives a usable range of plug values of {NUM_ISA_INTERRUPTS..63}. Note
|
|
* that there is no constraint on how many in this set an individual thread
|
|
* can acquire.
|
|
*/
|
|
|
|
struct ps3_bmp {
|
|
struct {
|
|
u64 status;
|
|
u64 unused_1[3];
|
|
u64 mask;
|
|
u64 unused_2[3];
|
|
};
|
|
u64 ipi_debug_brk_mask;
|
|
spinlock_t lock;
|
|
};
|
|
|
|
/**
|
|
* struct ps3_private - a per cpu data structure
|
|
* @bmp: ps3_bmp structure
|
|
* @node: HV logical_ppe_id
|
|
* @cpu: HV thread_id
|
|
*/
|
|
|
|
struct ps3_private {
|
|
struct ps3_bmp bmp __attribute__ ((aligned (64)));
|
|
u64 node;
|
|
unsigned int cpu;
|
|
};
|
|
|
|
static DEFINE_PER_CPU(struct ps3_private, ps3_private);
|
|
|
|
static int ps3_connect_irq(enum ps3_cpu_binding cpu, unsigned long outlet,
|
|
unsigned int *virq)
|
|
{
|
|
int result;
|
|
struct ps3_private *pd;
|
|
|
|
/* This defines the default interrupt distribution policy. */
|
|
|
|
if (cpu == PS3_BINDING_CPU_ANY)
|
|
cpu = 0;
|
|
|
|
pd = &per_cpu(ps3_private, cpu);
|
|
|
|
*virq = irq_create_mapping(NULL, outlet);
|
|
|
|
if (*virq == NO_IRQ) {
|
|
pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
|
|
__func__, __LINE__, outlet);
|
|
result = -ENOMEM;
|
|
goto fail_create;
|
|
}
|
|
|
|
/* Binds outlet to cpu + virq. */
|
|
|
|
result = lv1_connect_irq_plug_ext(pd->node, pd->cpu, *virq, outlet, 0);
|
|
|
|
if (result) {
|
|
pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
result = -EPERM;
|
|
goto fail_connect;
|
|
}
|
|
|
|
pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__,
|
|
outlet, cpu, *virq);
|
|
|
|
result = set_irq_chip_data(*virq, pd);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: set_irq_chip_data failed\n",
|
|
__func__, __LINE__);
|
|
goto fail_set;
|
|
}
|
|
|
|
return result;
|
|
|
|
fail_set:
|
|
lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, *virq);
|
|
fail_connect:
|
|
irq_dispose_mapping(*virq);
|
|
fail_create:
|
|
return result;
|
|
}
|
|
|
|
static void ps3_disconnect_irq(unsigned int virq)
|
|
{
|
|
int result;
|
|
const struct ps3_private *pd = get_irq_chip_data(virq);
|
|
|
|
pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__,
|
|
pd->node, pd->cpu, virq);
|
|
|
|
result = lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, virq);
|
|
|
|
if (result)
|
|
pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
|
|
set_irq_chip_data(virq, NULL);
|
|
irq_dispose_mapping(virq);
|
|
}
|
|
|
|
/**
|
|
* ps3_alloc_io_irq - Assign a virq to a system bus device.
|
|
* @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
|
|
* serviced on.
|
|
* @interrupt_id: The device interrupt id read from the system repository.
|
|
* @virq: The assigned Linux virq.
|
|
*
|
|
* An io irq represents a non-virtualized device interrupt. interrupt_id
|
|
* coresponds to the interrupt number of the interrupt controller.
|
|
*/
|
|
|
|
int ps3_alloc_io_irq(enum ps3_cpu_binding cpu, unsigned int interrupt_id,
|
|
unsigned int *virq)
|
|
{
|
|
int result;
|
|
unsigned long outlet;
|
|
|
|
result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
return result;
|
|
}
|
|
|
|
result = ps3_connect_irq(cpu, outlet, virq);
|
|
BUG_ON(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int ps3_free_io_irq(unsigned int virq)
|
|
{
|
|
int result;
|
|
|
|
result = lv1_destruct_io_irq_outlet(virq_to_hw(virq));
|
|
|
|
if (result)
|
|
pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
|
|
ps3_disconnect_irq(virq);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* ps3_alloc_event_irq - Allocate a virq for use with a system event.
|
|
* @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
|
|
* serviced on.
|
|
* @virq: The assigned Linux virq.
|
|
*
|
|
* The virq can be used with lv1_connect_interrupt_event_receive_port() to
|
|
* arrange to receive events, or with ps3_send_event_locally() to signal
|
|
* events.
|
|
*/
|
|
|
|
int ps3_alloc_event_irq(enum ps3_cpu_binding cpu, unsigned int *virq)
|
|
{
|
|
int result;
|
|
unsigned long outlet;
|
|
|
|
result = lv1_construct_event_receive_port(&outlet);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
*virq = NO_IRQ;
|
|
return result;
|
|
}
|
|
|
|
result = ps3_connect_irq(cpu, outlet, virq);
|
|
BUG_ON(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int ps3_free_event_irq(unsigned int virq)
|
|
{
|
|
int result;
|
|
|
|
pr_debug(" -> %s:%d\n", __func__, __LINE__);
|
|
|
|
result = lv1_destruct_event_receive_port(virq_to_hw(virq));
|
|
|
|
if (result)
|
|
pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
|
|
ps3_disconnect_irq(virq);
|
|
|
|
pr_debug(" <- %s:%d\n", __func__, __LINE__);
|
|
return result;
|
|
}
|
|
|
|
int ps3_send_event_locally(unsigned int virq)
|
|
{
|
|
return lv1_send_event_locally(virq_to_hw(virq));
|
|
}
|
|
|
|
/**
|
|
* ps3_connect_event_irq - Assign a virq to a system bus device.
|
|
* @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
|
|
* serviced on.
|
|
* @did: The HV device identifier read from the system repository.
|
|
* @interrupt_id: The device interrupt id read from the system repository.
|
|
* @virq: The assigned Linux virq.
|
|
*
|
|
* An event irq represents a virtual device interrupt. The interrupt_id
|
|
* coresponds to the software interrupt number.
|
|
*/
|
|
|
|
int ps3_connect_event_irq(enum ps3_cpu_binding cpu,
|
|
const struct ps3_device_id *did, unsigned int interrupt_id,
|
|
unsigned int *virq)
|
|
{
|
|
int result;
|
|
|
|
result = ps3_alloc_event_irq(cpu, virq);
|
|
|
|
if (result)
|
|
return result;
|
|
|
|
result = lv1_connect_interrupt_event_receive_port(did->bus_id,
|
|
did->dev_id, virq_to_hw(*virq), interrupt_id);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
|
|
" failed: %s\n", __func__, __LINE__,
|
|
ps3_result(result));
|
|
ps3_free_event_irq(*virq);
|
|
*virq = NO_IRQ;
|
|
return result;
|
|
}
|
|
|
|
pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
|
|
interrupt_id, *virq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ps3_disconnect_event_irq(const struct ps3_device_id *did,
|
|
unsigned int interrupt_id, unsigned int virq)
|
|
{
|
|
int result;
|
|
|
|
pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
|
|
interrupt_id, virq);
|
|
|
|
result = lv1_disconnect_interrupt_event_receive_port(did->bus_id,
|
|
did->dev_id, virq_to_hw(virq), interrupt_id);
|
|
|
|
if (result)
|
|
pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
|
|
" failed: %s\n", __func__, __LINE__,
|
|
ps3_result(result));
|
|
|
|
ps3_free_event_irq(virq);
|
|
|
|
pr_debug(" <- %s:%d\n", __func__, __LINE__);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* ps3_alloc_vuart_irq - Configure the system virtual uart virq.
|
|
* @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
|
|
* serviced on.
|
|
* @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
|
|
* @virq: The assigned Linux virq.
|
|
*
|
|
* The system supports only a single virtual uart, so multiple calls without
|
|
* freeing the interrupt will return a wrong state error.
|
|
*/
|
|
|
|
int ps3_alloc_vuart_irq(enum ps3_cpu_binding cpu, void* virt_addr_bmp,
|
|
unsigned int *virq)
|
|
{
|
|
int result;
|
|
unsigned long outlet;
|
|
u64 lpar_addr;
|
|
|
|
BUG_ON(!is_kernel_addr((u64)virt_addr_bmp));
|
|
|
|
lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));
|
|
|
|
result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
return result;
|
|
}
|
|
|
|
result = ps3_connect_irq(cpu, outlet, virq);
|
|
BUG_ON(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int ps3_free_vuart_irq(unsigned int virq)
|
|
{
|
|
int result;
|
|
|
|
result = lv1_deconfigure_virtual_uart_irq();
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
return result;
|
|
}
|
|
|
|
ps3_disconnect_irq(virq);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* ps3_alloc_spe_irq - Configure an spe virq.
|
|
* @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
|
|
* serviced on.
|
|
* @spe_id: The spe_id returned from lv1_construct_logical_spe().
|
|
* @class: The spe interrupt class {0,1,2}.
|
|
* @virq: The assigned Linux virq.
|
|
*
|
|
*/
|
|
|
|
int ps3_alloc_spe_irq(enum ps3_cpu_binding cpu, unsigned long spe_id,
|
|
unsigned int class, unsigned int *virq)
|
|
{
|
|
int result;
|
|
unsigned long outlet;
|
|
|
|
BUG_ON(class > 2);
|
|
|
|
result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);
|
|
|
|
if (result) {
|
|
pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
|
|
__func__, __LINE__, ps3_result(result));
|
|
return result;
|
|
}
|
|
|
|
result = ps3_connect_irq(cpu, outlet, virq);
|
|
BUG_ON(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int ps3_free_spe_irq(unsigned int virq)
|
|
{
|
|
ps3_disconnect_irq(virq);
|
|
return 0;
|
|
}
|
|
|
|
#define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
|
|
#define PS3_PLUG_MAX 63
|
|
|
|
#if defined(DEBUG)
|
|
static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu,
|
|
const char* func, int line)
|
|
{
|
|
pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
|
|
func, line, header, cpu,
|
|
*p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
|
|
*p & 0xffff);
|
|
}
|
|
|
|
static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
|
|
const u64 *p, unsigned cpu, const char* func, int line)
|
|
{
|
|
pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
|
|
func, line, header, cpu, p[0], p[1], p[2], p[3]);
|
|
}
|
|
|
|
#define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
|
|
static void _dump_bmp(struct ps3_private* pd, const char* func, int line)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&pd->bmp.lock, flags);
|
|
_dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
|
|
_dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
|
|
spin_unlock_irqrestore(&pd->bmp.lock, flags);
|
|
}
|
|
|
|
#define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
|
|
static void __attribute__ ((unused)) _dump_mask(struct ps3_private* pd,
|
|
const char* func, int line)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&pd->bmp.lock, flags);
|
|
_dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
|
|
spin_unlock_irqrestore(&pd->bmp.lock, flags);
|
|
}
|
|
#else
|
|
static void dump_bmp(struct ps3_private* pd) {};
|
|
#endif /* defined(DEBUG) */
|
|
|
|
static void ps3_chip_mask(unsigned int virq)
|
|
{
|
|
struct ps3_private *pd = get_irq_chip_data(virq);
|
|
u64 bit = 0x8000000000000000UL >> virq;
|
|
u64 *p = &pd->bmp.mask;
|
|
u64 old;
|
|
unsigned long flags;
|
|
|
|
pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
|
|
|
|
local_irq_save(flags);
|
|
asm volatile(
|
|
"1: ldarx %0,0,%3\n"
|
|
"andc %0,%0,%2\n"
|
|
"stdcx. %0,0,%3\n"
|
|
"bne- 1b"
|
|
: "=&r" (old), "+m" (*p)
|
|
: "r" (bit), "r" (p)
|
|
: "cc" );
|
|
|
|
lv1_did_update_interrupt_mask(pd->node, pd->cpu);
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
static void ps3_chip_unmask(unsigned int virq)
|
|
{
|
|
struct ps3_private *pd = get_irq_chip_data(virq);
|
|
u64 bit = 0x8000000000000000UL >> virq;
|
|
u64 *p = &pd->bmp.mask;
|
|
u64 old;
|
|
unsigned long flags;
|
|
|
|
pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
|
|
|
|
local_irq_save(flags);
|
|
asm volatile(
|
|
"1: ldarx %0,0,%3\n"
|
|
"or %0,%0,%2\n"
|
|
"stdcx. %0,0,%3\n"
|
|
"bne- 1b"
|
|
: "=&r" (old), "+m" (*p)
|
|
: "r" (bit), "r" (p)
|
|
: "cc" );
|
|
|
|
lv1_did_update_interrupt_mask(pd->node, pd->cpu);
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
static void ps3_chip_eoi(unsigned int virq)
|
|
{
|
|
const struct ps3_private *pd = get_irq_chip_data(virq);
|
|
lv1_end_of_interrupt_ext(pd->node, pd->cpu, virq);
|
|
}
|
|
|
|
static struct irq_chip irq_chip = {
|
|
.typename = "ps3",
|
|
.mask = ps3_chip_mask,
|
|
.unmask = ps3_chip_unmask,
|
|
.eoi = ps3_chip_eoi,
|
|
};
|
|
|
|
static void ps3_host_unmap(struct irq_host *h, unsigned int virq)
|
|
{
|
|
set_irq_chip_data(virq, NULL);
|
|
}
|
|
|
|
static int ps3_host_map(struct irq_host *h, unsigned int virq,
|
|
irq_hw_number_t hwirq)
|
|
{
|
|
pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq,
|
|
virq);
|
|
|
|
set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct irq_host_ops ps3_host_ops = {
|
|
.map = ps3_host_map,
|
|
.unmap = ps3_host_unmap,
|
|
};
|
|
|
|
void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
|
|
{
|
|
struct ps3_private *pd = &per_cpu(ps3_private, cpu);
|
|
|
|
pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
|
|
|
|
pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
|
|
cpu, virq, pd->bmp.ipi_debug_brk_mask);
|
|
}
|
|
|
|
unsigned int ps3_get_irq(void)
|
|
{
|
|
struct ps3_private *pd = &__get_cpu_var(ps3_private);
|
|
u64 x = (pd->bmp.status & pd->bmp.mask);
|
|
unsigned int plug;
|
|
|
|
/* check for ipi break first to stop this cpu ASAP */
|
|
|
|
if (x & pd->bmp.ipi_debug_brk_mask)
|
|
x &= pd->bmp.ipi_debug_brk_mask;
|
|
|
|
asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x));
|
|
plug &= 0x3f;
|
|
|
|
if (unlikely(plug) == NO_IRQ) {
|
|
pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
|
|
pd->cpu);
|
|
dump_bmp(&per_cpu(ps3_private, 0));
|
|
dump_bmp(&per_cpu(ps3_private, 1));
|
|
return NO_IRQ;
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) {
|
|
dump_bmp(&per_cpu(ps3_private, 0));
|
|
dump_bmp(&per_cpu(ps3_private, 1));
|
|
BUG();
|
|
}
|
|
#endif
|
|
return plug;
|
|
}
|
|
|
|
void __init ps3_init_IRQ(void)
|
|
{
|
|
int result;
|
|
unsigned cpu;
|
|
struct irq_host *host;
|
|
|
|
host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops,
|
|
PS3_INVALID_OUTLET);
|
|
irq_set_default_host(host);
|
|
irq_set_virq_count(PS3_PLUG_MAX + 1);
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
struct ps3_private *pd = &per_cpu(ps3_private, cpu);
|
|
|
|
lv1_get_logical_ppe_id(&pd->node);
|
|
pd->cpu = get_hard_smp_processor_id(cpu);
|
|
spin_lock_init(&pd->bmp.lock);
|
|
|
|
pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__,
|
|
__LINE__, pd->node, pd->cpu,
|
|
ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
|
|
|
|
result = lv1_configure_irq_state_bitmap(pd->node, pd->cpu,
|
|
ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
|
|
|
|
if (result)
|
|
pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
|
|
" %s\n", __func__, __LINE__,
|
|
ps3_result(result));
|
|
}
|
|
|
|
ppc_md.get_irq = ps3_get_irq;
|
|
}
|