2007-06-13 14:01:04 +07:00
|
|
|
/* irq.c: UltraSparc IRQ handling/init/registry.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2008-04-26 16:19:18 +07:00
|
|
|
* Copyright (C) 1997, 2007, 2008 David S. Miller (davem@davemloft.net)
|
2005-04-17 05:20:36 +07:00
|
|
|
* Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
|
|
|
|
* Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
2008-09-17 01:44:00 +07:00
|
|
|
#include <linux/linkage.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2010-04-07 18:41:33 +07:00
|
|
|
#include <linux/ftrace.h>
|
2006-06-20 15:23:32 +07:00
|
|
|
#include <linux/irq.h>
|
2010-04-14 04:28:24 +07:00
|
|
|
#include <linux/kmemleak.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
#include <asm/processor.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/irq.h>
|
2005-10-09 11:12:04 +07:00
|
|
|
#include <asm/io.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/upa.h>
|
|
|
|
#include <asm/oplib.h>
|
2006-06-23 10:21:22 +07:00
|
|
|
#include <asm/prom.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/timer.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/starfire.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/cache.h>
|
|
|
|
#include <asm/cpudata.h>
|
2005-06-28 07:04:45 +07:00
|
|
|
#include <asm/auxio.h>
|
2006-02-27 14:27:19 +07:00
|
|
|
#include <asm/head.h>
|
2007-06-13 14:01:04 +07:00
|
|
|
#include <asm/hypervisor.h>
|
2007-10-14 13:03:21 +07:00
|
|
|
#include <asm/cacheflush.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-03-26 14:37:51 +07:00
|
|
|
#include "entry.h"
|
2009-06-04 16:10:11 +07:00
|
|
|
#include "cpumap.h"
|
2010-04-14 16:04:29 +07:00
|
|
|
#include "kstack.h"
|
2006-06-20 15:23:32 +07:00
|
|
|
|
2007-10-14 11:43:31 +07:00
|
|
|
struct ino_bucket *ivector_table;
|
2007-10-14 11:42:46 +07:00
|
|
|
unsigned long ivector_table_pa;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-14 13:03:21 +07:00
|
|
|
/* On several sun4u processors, it is illegal to mix bypass and
|
|
|
|
* non-bypass accesses. Therefore we access all INO buckets
|
|
|
|
* using bypass accesses only.
|
|
|
|
*/
|
|
|
|
static unsigned long bucket_get_chain_pa(unsigned long bucket_pa)
|
|
|
|
{
|
|
|
|
unsigned long ret;
|
|
|
|
|
|
|
|
__asm__ __volatile__("ldxa [%1] %2, %0"
|
|
|
|
: "=&r" (ret)
|
|
|
|
: "r" (bucket_pa +
|
|
|
|
offsetof(struct ino_bucket,
|
|
|
|
__irq_chain_pa)),
|
|
|
|
"i" (ASI_PHYS_USE_EC));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bucket_clear_chain_pa(unsigned long bucket_pa)
|
|
|
|
{
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (bucket_pa +
|
|
|
|
offsetof(struct ino_bucket,
|
|
|
|
__irq_chain_pa)),
|
|
|
|
"i" (ASI_PHYS_USE_EC));
|
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:19 +07:00
|
|
|
static unsigned int bucket_get_irq(unsigned long bucket_pa)
|
2007-10-14 13:03:21 +07:00
|
|
|
{
|
|
|
|
unsigned int ret;
|
|
|
|
|
|
|
|
__asm__ __volatile__("lduwa [%1] %2, %0"
|
|
|
|
: "=&r" (ret)
|
|
|
|
: "r" (bucket_pa +
|
|
|
|
offsetof(struct ino_bucket,
|
2011-01-22 18:32:19 +07:00
|
|
|
__irq)),
|
2007-10-14 13:03:21 +07:00
|
|
|
"i" (ASI_PHYS_USE_EC));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:19 +07:00
|
|
|
static void bucket_set_irq(unsigned long bucket_pa, unsigned int irq)
|
2007-10-14 13:03:21 +07:00
|
|
|
{
|
|
|
|
__asm__ __volatile__("stwa %0, [%1] %2"
|
|
|
|
: /* no outputs */
|
2011-01-22 18:32:19 +07:00
|
|
|
: "r" (irq),
|
2007-10-14 13:03:21 +07:00
|
|
|
"r" (bucket_pa +
|
|
|
|
offsetof(struct ino_bucket,
|
2011-01-22 18:32:19 +07:00
|
|
|
__irq)),
|
2007-10-14 13:03:21 +07:00
|
|
|
"i" (ASI_PHYS_USE_EC));
|
|
|
|
}
|
|
|
|
|
2007-10-14 11:42:46 +07:00
|
|
|
#define irq_work_pa(__cpu) &(trap_block[(__cpu)].irq_worklist_pa)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned long hvirq_major __initdata;
|
|
|
|
static int __init early_hvirq_major(char *p)
|
|
|
|
{
|
|
|
|
int rc = kstrtoul(p, 10, &hvirq_major);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
early_param("hvirq", early_hvirq_major);
|
|
|
|
|
|
|
|
static int hv_irq_version;
|
|
|
|
|
|
|
|
/* Major version 2.0 of HV_GRP_INTR added support for the VIRQ cookie
|
|
|
|
* based interfaces, but:
|
|
|
|
*
|
|
|
|
* 1) Several OSs, Solaris and Linux included, use them even when only
|
|
|
|
* negotiating version 1.0 (or failing to negotiate at all). So the
|
|
|
|
* hypervisor has a workaround that provides the VIRQ interfaces even
|
|
|
|
* when only verion 1.0 of the API is in use.
|
|
|
|
*
|
|
|
|
* 2) Second, and more importantly, with major version 2.0 these VIRQ
|
|
|
|
* interfaces only were actually hooked up for LDC interrupts, even
|
|
|
|
* though the Hypervisor specification clearly stated:
|
|
|
|
*
|
|
|
|
* The new interrupt API functions will be available to a guest
|
|
|
|
* when it negotiates version 2.0 in the interrupt API group 0x2. When
|
|
|
|
* a guest negotiates version 2.0, all interrupt sources will only
|
|
|
|
* support using the cookie interface, and any attempt to use the
|
|
|
|
* version 1.0 interrupt APIs numbered 0xa0 to 0xa6 will result in the
|
|
|
|
* ENOTSUPPORTED error being returned.
|
|
|
|
*
|
|
|
|
* with an emphasis on "all interrupt sources".
|
|
|
|
*
|
|
|
|
* To correct this, major version 3.0 was created which does actually
|
|
|
|
* support VIRQs for all interrupt sources (not just LDC devices). So
|
|
|
|
* if we want to move completely over the cookie based VIRQs we must
|
|
|
|
* negotiate major version 3.0 or later of HV_GRP_INTR.
|
|
|
|
*/
|
|
|
|
static bool sun4v_cookie_only_virqs(void)
|
|
|
|
{
|
|
|
|
if (hv_irq_version >= 3)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static void __init irq_init_hv(void)
|
2006-06-20 15:22:35 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long hv_error, major, minor = 0;
|
|
|
|
|
|
|
|
if (tlb_type != hypervisor)
|
|
|
|
return;
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
if (hvirq_major)
|
|
|
|
major = hvirq_major;
|
|
|
|
else
|
|
|
|
major = 3;
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
hv_error = sun4v_hvapi_register(HV_GRP_INTR, major, &minor);
|
|
|
|
if (!hv_error)
|
|
|
|
hv_irq_version = major;
|
|
|
|
else
|
|
|
|
hv_irq_version = 1;
|
2007-10-11 17:16:13 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
pr_info("SUN4V: Using IRQ API major %d, cookie only virqs %s\n",
|
|
|
|
hv_irq_version,
|
|
|
|
sun4v_cookie_only_virqs() ? "enabled" : "disabled");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This function is for the timer interrupt.*/
|
|
|
|
int __init arch_probe_nr_irqs(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DEFAULT_NUM_IVECS (0xfffU)
|
|
|
|
static unsigned int nr_ivec = DEFAULT_NUM_IVECS;
|
|
|
|
#define NUM_IVECS (nr_ivec)
|
|
|
|
|
|
|
|
static unsigned int __init size_nr_ivec(void)
|
|
|
|
{
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
switch (sun4v_chip_type) {
|
|
|
|
/* Athena's devhandle|devino is large.*/
|
|
|
|
case SUN4V_CHIP_SPARC64X:
|
|
|
|
nr_ivec = 0xffff;
|
[SPARC64]: Add PCI MSI support on Niagara.
This is kind of hokey, we could use the hardware provided facilities
much better.
MSIs are assosciated with MSI Queues. MSI Queues generate interrupts
when any MSI assosciated with it is signalled. This suggests a
two-tiered IRQ dispatch scheme:
MSI Queue interrupt --> queue interrupt handler
MSI dispatch --> driver interrupt handler
But we just get one-level under Linux currently. What I'd like to do
is possibly stick the IRQ actions into a per-MSI-Queue data structure,
and dispatch them form there, but the generic IRQ layer doesn't
provide a way to do that right now.
So, the current kludge is to "ACK" the interrupt by processing the
MSI Queue data structures and ACK'ing them, then we run the actual
handler like normal.
We are wasting a lot of useful information, for example the MSI data
and address are provided with ever MSI, as well as a system tick if
available. If we could pass this into the IRQ handler it could help
with certain things, in particular for PCI-Express error messages.
The MSI entries on sparc64 also tell you exactly which bus/device/fn
sent the MSI, which would be great for error handling when no
registered IRQ handler can service the interrupt.
We override the disable/enable IRQ chip methods in sun4v_msi, so we
have to call {mask,unmask}_msi_irq() directly from there. This is
another ugly wart.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-02-11 08:41:02 +07:00
|
|
|
break;
|
2014-09-26 02:25:03 +07:00
|
|
|
}
|
[SPARC64]: Add PCI MSI support on Niagara.
This is kind of hokey, we could use the hardware provided facilities
much better.
MSIs are assosciated with MSI Queues. MSI Queues generate interrupts
when any MSI assosciated with it is signalled. This suggests a
two-tiered IRQ dispatch scheme:
MSI Queue interrupt --> queue interrupt handler
MSI dispatch --> driver interrupt handler
But we just get one-level under Linux currently. What I'd like to do
is possibly stick the IRQ actions into a per-MSI-Queue data structure,
and dispatch them form there, but the generic IRQ layer doesn't
provide a way to do that right now.
So, the current kludge is to "ACK" the interrupt by processing the
MSI Queue data structures and ACK'ing them, then we run the actual
handler like normal.
We are wasting a lot of useful information, for example the MSI data
and address are provided with ever MSI, as well as a system tick if
available. If we could pass this into the IRQ handler it could help
with certain things, in particular for PCI-Express error messages.
The MSI entries on sparc64 also tell you exactly which bus/device/fn
sent the MSI, which would be great for error handling when no
registered IRQ handler can service the interrupt.
We override the disable/enable IRQ chip methods in sun4v_msi, so we
have to call {mask,unmask}_msi_irq() directly from there. This is
another ugly wart.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-02-11 08:41:02 +07:00
|
|
|
}
|
2014-09-26 02:25:03 +07:00
|
|
|
return nr_ivec;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct irq_handler_data {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
unsigned int dev_handle;
|
|
|
|
unsigned int dev_ino;
|
|
|
|
};
|
|
|
|
unsigned long sysino;
|
|
|
|
};
|
|
|
|
struct ino_bucket bucket;
|
|
|
|
unsigned long iclr;
|
|
|
|
unsigned long imap;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline unsigned int irq_data_to_handle(struct irq_data *data)
|
|
|
|
{
|
|
|
|
struct irq_handler_data *ihd = data->handler_data;
|
|
|
|
|
|
|
|
return ihd->dev_handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int irq_data_to_ino(struct irq_data *data)
|
|
|
|
{
|
|
|
|
struct irq_handler_data *ihd = data->handler_data;
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
return ihd->dev_ino;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long irq_data_to_sysino(struct irq_data *data)
|
|
|
|
{
|
|
|
|
struct irq_handler_data *ihd = data->handler_data;
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
return ihd->sysino;
|
2006-06-20 15:22:35 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:19 +07:00
|
|
|
void irq_free(unsigned int irq)
|
2006-06-20 15:22:35 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
void *data = irq_get_handler_data(irq);
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
kfree(data);
|
|
|
|
irq_set_handler_data(irq, NULL);
|
|
|
|
irq_free_descs(irq, 1);
|
|
|
|
}
|
[SPARC64]: Add PCI MSI support on Niagara.
This is kind of hokey, we could use the hardware provided facilities
much better.
MSIs are assosciated with MSI Queues. MSI Queues generate interrupts
when any MSI assosciated with it is signalled. This suggests a
two-tiered IRQ dispatch scheme:
MSI Queue interrupt --> queue interrupt handler
MSI dispatch --> driver interrupt handler
But we just get one-level under Linux currently. What I'd like to do
is possibly stick the IRQ actions into a per-MSI-Queue data structure,
and dispatch them form there, but the generic IRQ layer doesn't
provide a way to do that right now.
So, the current kludge is to "ACK" the interrupt by processing the
MSI Queue data structures and ACK'ing them, then we run the actual
handler like normal.
We are wasting a lot of useful information, for example the MSI data
and address are provided with ever MSI, as well as a system tick if
available. If we could pass this into the IRQ handler it could help
with certain things, in particular for PCI-Express error messages.
The MSI entries on sparc64 also tell you exactly which bus/device/fn
sent the MSI, which would be great for error handling when no
registered IRQ handler can service the interrupt.
We override the disable/enable IRQ chip methods in sun4v_msi, so we
have to call {mask,unmask}_msi_irq() directly from there. This is
another ugly wart.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-02-11 08:41:02 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int irq_alloc(unsigned int dev_handle, unsigned int dev_ino)
|
|
|
|
{
|
|
|
|
int irq;
|
2007-10-11 17:16:13 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq = __irq_alloc_descs(-1, 1, 1, numa_node_id(), NULL);
|
|
|
|
if (irq <= 0)
|
|
|
|
goto out;
|
[SPARC64]: Add PCI MSI support on Niagara.
This is kind of hokey, we could use the hardware provided facilities
much better.
MSIs are assosciated with MSI Queues. MSI Queues generate interrupts
when any MSI assosciated with it is signalled. This suggests a
two-tiered IRQ dispatch scheme:
MSI Queue interrupt --> queue interrupt handler
MSI dispatch --> driver interrupt handler
But we just get one-level under Linux currently. What I'd like to do
is possibly stick the IRQ actions into a per-MSI-Queue data structure,
and dispatch them form there, but the generic IRQ layer doesn't
provide a way to do that right now.
So, the current kludge is to "ACK" the interrupt by processing the
MSI Queue data structures and ACK'ing them, then we run the actual
handler like normal.
We are wasting a lot of useful information, for example the MSI data
and address are provided with ever MSI, as well as a system tick if
available. If we could pass this into the IRQ handler it could help
with certain things, in particular for PCI-Express error messages.
The MSI entries on sparc64 also tell you exactly which bus/device/fn
sent the MSI, which would be great for error handling when no
registered IRQ handler can service the interrupt.
We override the disable/enable IRQ chip methods in sun4v_msi, so we
have to call {mask,unmask}_msi_irq() directly from there. This is
another ugly wart.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-02-11 08:41:02 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
return irq;
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int cookie_exists(u32 devhandle, unsigned int devino)
|
|
|
|
{
|
|
|
|
unsigned long hv_err, cookie;
|
|
|
|
struct ino_bucket *bucket;
|
|
|
|
unsigned int irq = 0U;
|
|
|
|
|
|
|
|
hv_err = sun4v_vintr_get_cookie(devhandle, devino, &cookie);
|
|
|
|
if (hv_err) {
|
|
|
|
pr_err("HV get cookie failed hv_err = %ld\n", hv_err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cookie & ((1UL << 63UL))) {
|
|
|
|
cookie = ~cookie;
|
|
|
|
bucket = (struct ino_bucket *) __va(cookie);
|
|
|
|
irq = bucket->__irq;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int sysino_exists(u32 devhandle, unsigned int devino)
|
|
|
|
{
|
|
|
|
unsigned long sysino = sun4v_devino_to_sysino(devhandle, devino);
|
|
|
|
struct ino_bucket *bucket;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
bucket = &ivector_table[sysino];
|
|
|
|
irq = bucket_get_irq(__pa(bucket));
|
|
|
|
|
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ack_bad_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
pr_crit("BAD IRQ ack %d\n", irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_install_pre_handler(int irq,
|
|
|
|
void (*func)(unsigned int, void *, void *),
|
|
|
|
void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
pr_warn("IRQ pre handler NOT supported.\n");
|
2006-06-20 15:22:35 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2006-06-20 15:23:32 +07:00
|
|
|
* /proc/interrupts printing:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2011-03-25 00:03:13 +07:00
|
|
|
int arch_show_interrupts(struct seq_file *p, int prec)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2011-03-25 00:03:13 +07:00
|
|
|
int j;
|
2006-06-20 15:23:32 +07:00
|
|
|
|
2011-03-25 00:03:13 +07:00
|
|
|
seq_printf(p, "NMI: ");
|
|
|
|
for_each_online_cpu(j)
|
|
|
|
seq_printf(p, "%10u ", cpu_data(j).__nmi_count);
|
|
|
|
seq_printf(p, " Non-maskable interrupts\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-02-17 23:38:06 +07:00
|
|
|
static unsigned int sun4u_compute_tid(unsigned long imap, unsigned long cpuid)
|
|
|
|
{
|
|
|
|
unsigned int tid;
|
|
|
|
|
|
|
|
if (this_is_starfire) {
|
|
|
|
tid = starfire_translate(imap, cpuid);
|
|
|
|
tid <<= IMAP_TID_SHIFT;
|
|
|
|
tid &= IMAP_TID_UPA;
|
|
|
|
} else {
|
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
|
|
|
unsigned long ver;
|
|
|
|
|
|
|
|
__asm__ ("rdpr %%ver, %0" : "=r" (ver));
|
|
|
|
if ((ver >> 32UL) == __JALAPENO_ID ||
|
|
|
|
(ver >> 32UL) == __SERRANO_ID) {
|
|
|
|
tid = cpuid << IMAP_TID_SHIFT;
|
|
|
|
tid &= IMAP_TID_JBUS;
|
|
|
|
} else {
|
|
|
|
unsigned int a = cpuid & 0x1f;
|
|
|
|
unsigned int n = (cpuid >> 5) & 0x1f;
|
|
|
|
|
|
|
|
tid = ((a << IMAP_AID_SHIFT) |
|
|
|
|
(n << IMAP_NID_SHIFT));
|
|
|
|
tid &= (IMAP_AID_SAFARI |
|
2009-08-19 01:18:35 +07:00
|
|
|
IMAP_NID_SAFARI);
|
2006-02-17 23:38:06 +07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
tid = cpuid << IMAP_TID_SHIFT;
|
|
|
|
tid &= IMAP_TID_UPA;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return tid;
|
|
|
|
}
|
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2011-01-22 18:32:19 +07:00
|
|
|
static int irq_choose_cpu(unsigned int irq, const struct cpumask *affinity)
|
2005-07-05 03:24:38 +07:00
|
|
|
{
|
2009-01-13 06:27:13 +07:00
|
|
|
cpumask_t mask;
|
2006-06-20 15:23:32 +07:00
|
|
|
int cpuid;
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2010-01-21 10:30:49 +07:00
|
|
|
cpumask_copy(&mask, affinity);
|
2011-05-17 03:38:07 +07:00
|
|
|
if (cpumask_equal(&mask, cpu_online_mask)) {
|
2011-01-22 18:32:19 +07:00
|
|
|
cpuid = map_to_cpu(irq);
|
2006-06-20 15:23:32 +07:00
|
|
|
} else {
|
|
|
|
cpumask_t tmp;
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_and(&tmp, cpu_online_mask, &mask);
|
|
|
|
cpuid = cpumask_empty(&tmp) ? map_to_cpu(irq) : cpumask_first(&tmp);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
return cpuid;
|
|
|
|
}
|
|
|
|
#else
|
2011-01-22 18:32:19 +07:00
|
|
|
#define irq_choose_cpu(irq, affinity) \
|
2010-01-26 19:16:49 +07:00
|
|
|
real_hard_smp_processor_id()
|
2006-06-20 15:23:32 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4u_irq_enable(struct irq_data *data)
|
2006-02-14 09:16:10 +07:00
|
|
|
{
|
2011-01-22 18:32:18 +07:00
|
|
|
struct irq_handler_data *handler_data = data->handler_data;
|
2006-02-14 09:16:10 +07:00
|
|
|
|
2011-01-22 18:32:16 +07:00
|
|
|
if (likely(handler_data)) {
|
2007-05-03 07:31:36 +07:00
|
|
|
unsigned long cpuid, imap, val;
|
2006-06-20 15:23:32 +07:00
|
|
|
unsigned int tid;
|
2006-02-14 09:16:10 +07:00
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
cpuid = irq_choose_cpu(data->irq, data->affinity);
|
2011-01-22 18:32:16 +07:00
|
|
|
imap = handler_data->imap;
|
2006-02-14 09:16:10 +07:00
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
tid = sun4u_compute_tid(imap, cpuid);
|
2006-02-14 09:16:10 +07:00
|
|
|
|
2007-05-03 07:31:36 +07:00
|
|
|
val = upa_readq(imap);
|
|
|
|
val &= ~(IMAP_TID_UPA | IMAP_TID_JBUS |
|
|
|
|
IMAP_AID_SAFARI | IMAP_NID_SAFARI);
|
|
|
|
val |= tid | IMAP_VALID;
|
|
|
|
upa_writeq(val, imap);
|
2011-01-22 18:32:16 +07:00
|
|
|
upa_writeq(ICLR_IDLE, handler_data->iclr);
|
2006-02-14 09:16:10 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static int sun4u_set_affinity(struct irq_data *data,
|
|
|
|
const struct cpumask *mask, bool force)
|
2007-07-14 17:16:13 +07:00
|
|
|
{
|
2011-01-22 18:32:18 +07:00
|
|
|
struct irq_handler_data *handler_data = data->handler_data;
|
2010-01-21 10:30:49 +07:00
|
|
|
|
2011-01-22 18:32:16 +07:00
|
|
|
if (likely(handler_data)) {
|
2010-01-21 10:30:49 +07:00
|
|
|
unsigned long cpuid, imap, val;
|
|
|
|
unsigned int tid;
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
cpuid = irq_choose_cpu(data->irq, mask);
|
2011-01-22 18:32:16 +07:00
|
|
|
imap = handler_data->imap;
|
2010-01-21 10:30:49 +07:00
|
|
|
|
|
|
|
tid = sun4u_compute_tid(imap, cpuid);
|
|
|
|
|
|
|
|
val = upa_readq(imap);
|
|
|
|
val &= ~(IMAP_TID_UPA | IMAP_TID_JBUS |
|
|
|
|
IMAP_AID_SAFARI | IMAP_NID_SAFARI);
|
|
|
|
val |= tid | IMAP_VALID;
|
|
|
|
upa_writeq(val, imap);
|
2011-01-22 18:32:16 +07:00
|
|
|
upa_writeq(ICLR_IDLE, handler_data->iclr);
|
2010-01-21 10:30:49 +07:00
|
|
|
}
|
2009-04-28 07:59:21 +07:00
|
|
|
|
|
|
|
return 0;
|
2007-07-14 17:16:13 +07:00
|
|
|
}
|
|
|
|
|
2009-03-05 05:43:47 +07:00
|
|
|
/* Don't do anything. The desc->status check for IRQ_DISABLED in
|
|
|
|
* handler_irq() will skip the handler call and that will leave the
|
|
|
|
* interrupt in the sent state. The next ->enable() call will hit the
|
|
|
|
* ICLR register to reset the state machine.
|
|
|
|
*
|
|
|
|
* This scheme is necessary, instead of clearing the Valid bit in the
|
|
|
|
* IMAP register, to handle the case of IMAP registers being shared by
|
|
|
|
* multiple INOs (and thus ICLR registers). Since we use a different
|
|
|
|
* virtual IRQ for each shared IMAP instance, the generic code thinks
|
|
|
|
* there is only one user so it prematurely calls ->disable() on
|
|
|
|
* free_irq().
|
|
|
|
*
|
|
|
|
* We have to provide an explicit ->disable() method instead of using
|
|
|
|
* NULL to get the default. The reason is that if the generic code
|
|
|
|
* sees that, it also hooks up a default ->shutdown method which
|
|
|
|
* invokes ->mask() which we do not want. See irq_chip_set_defaults().
|
|
|
|
*/
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4u_irq_disable(struct irq_data *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-07-05 03:24:38 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4u_irq_eoi(struct irq_data *data)
|
2005-07-05 03:24:38 +07:00
|
|
|
{
|
2011-01-22 18:32:18 +07:00
|
|
|
struct irq_handler_data *handler_data = data->handler_data;
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2011-01-22 18:32:16 +07:00
|
|
|
if (likely(handler_data))
|
|
|
|
upa_writeq(ICLR_IDLE, handler_data->iclr);
|
2005-07-05 03:24:38 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_irq_enable(struct irq_data *data)
|
2005-07-05 03:24:38 +07:00
|
|
|
{
|
2011-01-22 18:32:18 +07:00
|
|
|
unsigned long cpuid = irq_choose_cpu(data->irq, data->affinity);
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int ino = irq_data_to_sysino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = sun4v_intr_settarget(ino, cpuid);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_settarget(%x,%lu): "
|
|
|
|
"err(%d)\n", ino, cpuid, err);
|
|
|
|
err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_setstate(%x): "
|
|
|
|
"err(%d)\n", ino, err);
|
|
|
|
err = sun4v_intr_setenabled(ino, HV_INTR_ENABLED);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_setenabled(%x): err(%d)\n",
|
|
|
|
ino, err);
|
2005-07-05 03:24:38 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static int sun4v_set_affinity(struct irq_data *data,
|
|
|
|
const struct cpumask *mask, bool force)
|
2007-07-14 17:16:13 +07:00
|
|
|
{
|
2011-01-22 18:32:18 +07:00
|
|
|
unsigned long cpuid = irq_choose_cpu(data->irq, mask);
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int ino = irq_data_to_sysino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = sun4v_intr_settarget(ino, cpuid);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_settarget(%x,%lu): "
|
|
|
|
"err(%d)\n", ino, cpuid, err);
|
2009-04-28 07:59:21 +07:00
|
|
|
|
|
|
|
return 0;
|
2007-07-14 17:16:13 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_irq_disable(struct irq_data *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int ino = irq_data_to_sysino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-14 13:41:28 +07:00
|
|
|
err = sun4v_intr_setenabled(ino, HV_INTR_DISABLED);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_setenabled(%x): "
|
|
|
|
"err(%d)\n", ino, err);
|
2006-06-20 15:23:32 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_irq_eoi(struct irq_data *data)
|
2006-06-20 15:23:32 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int ino = irq_data_to_sysino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
2007-07-10 12:40:36 +07:00
|
|
|
|
2007-10-14 13:41:28 +07:00
|
|
|
err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_intr_setstate(%x): "
|
|
|
|
"err(%d)\n", ino, err);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_virq_enable(struct irq_data *data)
|
2007-06-13 14:01:04 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long dev_handle = irq_data_to_handle(data);
|
|
|
|
unsigned long dev_ino = irq_data_to_ino(data);
|
|
|
|
unsigned long cpuid;
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
cpuid = irq_choose_cpu(data->irq, data->affinity);
|
2007-10-14 13:41:28 +07:00
|
|
|
|
|
|
|
err = sun4v_vintr_set_target(dev_handle, dev_ino, cpuid);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_target(%lx,%lx,%lu): "
|
|
|
|
"err(%d)\n",
|
|
|
|
dev_handle, dev_ino, cpuid, err);
|
|
|
|
err = sun4v_vintr_set_state(dev_handle, dev_ino,
|
|
|
|
HV_INTR_STATE_IDLE);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_state(%lx,%lx,"
|
|
|
|
"HV_INTR_STATE_IDLE): err(%d)\n",
|
|
|
|
dev_handle, dev_ino, err);
|
|
|
|
err = sun4v_vintr_set_valid(dev_handle, dev_ino,
|
|
|
|
HV_INTR_ENABLED);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_state(%lx,%lx,"
|
|
|
|
"HV_INTR_ENABLED): err(%d)\n",
|
|
|
|
dev_handle, dev_ino, err);
|
2007-06-13 14:01:04 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static int sun4v_virt_set_affinity(struct irq_data *data,
|
|
|
|
const struct cpumask *mask, bool force)
|
2007-07-14 17:16:13 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long dev_handle = irq_data_to_handle(data);
|
|
|
|
unsigned long dev_ino = irq_data_to_ino(data);
|
|
|
|
unsigned long cpuid;
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
2007-07-14 17:16:13 +07:00
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
cpuid = irq_choose_cpu(data->irq, mask);
|
2007-07-14 17:16:13 +07:00
|
|
|
|
2007-10-14 13:41:28 +07:00
|
|
|
err = sun4v_vintr_set_target(dev_handle, dev_ino, cpuid);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_target(%lx,%lx,%lu): "
|
|
|
|
"err(%d)\n",
|
|
|
|
dev_handle, dev_ino, cpuid, err);
|
2009-04-28 07:59:21 +07:00
|
|
|
|
|
|
|
return 0;
|
2007-07-14 17:16:13 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_virq_disable(struct irq_data *data)
|
2007-06-13 14:01:04 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long dev_handle = irq_data_to_handle(data);
|
|
|
|
unsigned long dev_ino = irq_data_to_ino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
|
|
err = sun4v_vintr_set_valid(dev_handle, dev_ino,
|
|
|
|
HV_INTR_DISABLED);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_state(%lx,%lx,"
|
|
|
|
"HV_INTR_DISABLED): err(%d)\n",
|
|
|
|
dev_handle, dev_ino, err);
|
2007-06-13 14:01:04 +07:00
|
|
|
}
|
|
|
|
|
2011-01-22 18:32:18 +07:00
|
|
|
static void sun4v_virq_eoi(struct irq_data *data)
|
2007-06-13 14:01:04 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long dev_handle = irq_data_to_handle(data);
|
|
|
|
unsigned long dev_ino = irq_data_to_ino(data);
|
2007-10-14 13:41:28 +07:00
|
|
|
int err;
|
2007-07-10 12:40:36 +07:00
|
|
|
|
2007-10-14 13:41:28 +07:00
|
|
|
err = sun4v_vintr_set_state(dev_handle, dev_ino,
|
|
|
|
HV_INTR_STATE_IDLE);
|
|
|
|
if (err != HV_EOK)
|
|
|
|
printk(KERN_ERR "sun4v_vintr_set_state(%lx,%lx,"
|
|
|
|
"HV_INTR_STATE_IDLE): err(%d)\n",
|
|
|
|
dev_handle, dev_ino, err);
|
2007-06-13 14:01:04 +07:00
|
|
|
}
|
|
|
|
|
2006-12-12 15:59:12 +07:00
|
|
|
static struct irq_chip sun4u_irq = {
|
2011-01-22 18:32:18 +07:00
|
|
|
.name = "sun4u",
|
|
|
|
.irq_enable = sun4u_irq_enable,
|
|
|
|
.irq_disable = sun4u_irq_disable,
|
|
|
|
.irq_eoi = sun4u_irq_eoi,
|
|
|
|
.irq_set_affinity = sun4u_set_affinity,
|
2011-03-24 15:03:45 +07:00
|
|
|
.flags = IRQCHIP_EOI_IF_HANDLED,
|
2006-06-20 15:23:32 +07:00
|
|
|
};
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2006-12-12 15:59:12 +07:00
|
|
|
static struct irq_chip sun4v_irq = {
|
2011-01-22 18:32:18 +07:00
|
|
|
.name = "sun4v",
|
|
|
|
.irq_enable = sun4v_irq_enable,
|
|
|
|
.irq_disable = sun4v_irq_disable,
|
|
|
|
.irq_eoi = sun4v_irq_eoi,
|
|
|
|
.irq_set_affinity = sun4v_set_affinity,
|
2011-03-24 15:03:45 +07:00
|
|
|
.flags = IRQCHIP_EOI_IF_HANDLED,
|
2006-06-20 15:23:32 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-06-13 14:01:04 +07:00
|
|
|
static struct irq_chip sun4v_virq = {
|
2011-01-22 18:32:18 +07:00
|
|
|
.name = "vsun4v",
|
|
|
|
.irq_enable = sun4v_virq_enable,
|
|
|
|
.irq_disable = sun4v_virq_disable,
|
|
|
|
.irq_eoi = sun4v_virq_eoi,
|
|
|
|
.irq_set_affinity = sun4v_virt_set_affinity,
|
2011-03-24 15:03:45 +07:00
|
|
|
.flags = IRQCHIP_EOI_IF_HANDLED,
|
2007-06-13 14:01:04 +07:00
|
|
|
};
|
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
|
|
|
|
{
|
2011-01-22 18:32:16 +07:00
|
|
|
struct irq_handler_data *handler_data;
|
2014-09-26 02:25:03 +07:00
|
|
|
struct ino_bucket *bucket;
|
2011-01-22 18:32:19 +07:00
|
|
|
unsigned int irq;
|
2006-06-20 15:23:32 +07:00
|
|
|
int ino;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
BUG_ON(tlb_type == hypervisor);
|
2005-07-05 03:24:38 +07:00
|
|
|
|
2007-05-03 07:31:36 +07:00
|
|
|
ino = (upa_readq(imap) & (IMAP_IGN | IMAP_INO)) + inofixup;
|
2006-06-20 15:23:32 +07:00
|
|
|
bucket = &ivector_table[ino];
|
2011-01-22 18:32:19 +07:00
|
|
|
irq = bucket_get_irq(__pa(bucket));
|
|
|
|
if (!irq) {
|
|
|
|
irq = irq_alloc(0, ino);
|
|
|
|
bucket_set_irq(__pa(bucket), irq);
|
2011-03-24 23:52:54 +07:00
|
|
|
irq_set_chip_and_handler_name(irq, &sun4u_irq,
|
|
|
|
handle_fasteoi_irq, "IVEC");
|
2006-06-20 15:20:00 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-03-24 23:52:54 +07:00
|
|
|
handler_data = irq_get_handler_data(irq);
|
2011-01-22 18:32:16 +07:00
|
|
|
if (unlikely(handler_data))
|
2006-06-20 15:23:32 +07:00
|
|
|
goto out;
|
2006-06-20 15:20:00 +07:00
|
|
|
|
2011-01-22 18:32:16 +07:00
|
|
|
handler_data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
|
|
|
|
if (unlikely(!handler_data)) {
|
2006-06-20 15:23:32 +07:00
|
|
|
prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
|
|
|
|
prom_halt();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2011-03-24 23:52:54 +07:00
|
|
|
irq_set_handler_data(irq, handler_data);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-01-22 18:32:16 +07:00
|
|
|
handler_data->imap = imap;
|
|
|
|
handler_data->iclr = iclr;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
out:
|
2011-01-22 18:32:19 +07:00
|
|
|
return irq;
|
2006-06-20 15:23:32 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned int sun4v_build_common(u32 devhandle, unsigned int devino,
|
|
|
|
void (*handler_data_init)(struct irq_handler_data *data,
|
|
|
|
u32 devhandle, unsigned int devino),
|
|
|
|
struct irq_chip *chip)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
struct irq_handler_data *data;
|
2011-01-22 18:32:19 +07:00
|
|
|
unsigned int irq;
|
2006-06-20 15:22:35 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq = irq_alloc(devhandle, devino);
|
|
|
|
if (!irq)
|
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
|
|
|
|
if (unlikely(!data)) {
|
|
|
|
pr_err("IRQ handler data allocation failed.\n");
|
|
|
|
irq_free(irq);
|
|
|
|
irq = 0;
|
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq_set_handler_data(irq, data);
|
|
|
|
handler_data_init(data, devhandle, devino);
|
|
|
|
irq_set_chip_and_handler_name(irq, chip, handle_fasteoi_irq, "IVEC");
|
|
|
|
data->imap = ~0UL;
|
|
|
|
data->iclr = ~0UL;
|
|
|
|
out:
|
|
|
|
return irq;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned long cookie_assign(unsigned int irq, u32 devhandle,
|
|
|
|
unsigned int devino)
|
|
|
|
{
|
|
|
|
struct irq_handler_data *ihd = irq_get_handler_data(irq);
|
|
|
|
unsigned long hv_error, cookie;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
/* handler_irq needs to find the irq. cookie is seen signed in
|
|
|
|
* sun4v_dev_mondo and treated as a non ivector_table delivery.
|
2006-06-20 15:23:32 +07:00
|
|
|
*/
|
2014-09-26 02:25:03 +07:00
|
|
|
ihd->bucket.__irq = irq;
|
|
|
|
cookie = ~__pa(&ihd->bucket);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
hv_error = sun4v_vintr_set_cookie(devhandle, devino, cookie);
|
|
|
|
if (hv_error)
|
|
|
|
pr_err("HV vintr set cookie failed = %ld\n", hv_error);
|
|
|
|
|
|
|
|
return hv_error;
|
2006-06-20 15:23:32 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static void cookie_handler_data(struct irq_handler_data *data,
|
|
|
|
u32 devhandle, unsigned int devino)
|
2007-06-13 14:01:04 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
data->dev_handle = devhandle;
|
|
|
|
data->dev_ino = devino;
|
|
|
|
}
|
2007-06-13 14:01:04 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned int cookie_build_irq(u32 devhandle, unsigned int devino,
|
|
|
|
struct irq_chip *chip)
|
|
|
|
{
|
|
|
|
unsigned long hv_error;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
irq = sun4v_build_common(devhandle, devino, cookie_handler_data, chip);
|
|
|
|
|
|
|
|
hv_error = cookie_assign(irq, devhandle, devino);
|
|
|
|
if (hv_error) {
|
|
|
|
irq_free(irq);
|
|
|
|
irq = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return irq;
|
2007-06-13 14:01:04 +07:00
|
|
|
}
|
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned int sun4v_build_cookie(u32 devhandle, unsigned int devino)
|
2007-06-13 14:01:04 +07:00
|
|
|
{
|
2011-01-22 18:32:19 +07:00
|
|
|
unsigned int irq;
|
2007-10-14 11:51:37 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq = cookie_exists(devhandle, devino);
|
|
|
|
if (irq)
|
|
|
|
goto out;
|
2010-04-11 10:24:22 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq = cookie_build_irq(devhandle, devino, &sun4v_virq);
|
2010-04-11 10:24:22 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
out:
|
|
|
|
return irq;
|
|
|
|
}
|
2007-10-14 11:51:37 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static void sysino_set_bucket(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_handler_data *ihd = irq_get_handler_data(irq);
|
|
|
|
struct ino_bucket *bucket;
|
|
|
|
unsigned long sysino;
|
|
|
|
|
|
|
|
sysino = sun4v_devino_to_sysino(ihd->dev_handle, ihd->dev_ino);
|
|
|
|
BUG_ON(sysino >= nr_ivec);
|
|
|
|
bucket = &ivector_table[sysino];
|
2011-01-22 18:32:19 +07:00
|
|
|
bucket_set_irq(__pa(bucket), irq);
|
2014-09-26 02:25:03 +07:00
|
|
|
}
|
2007-10-22 16:16:45 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static void sysino_handler_data(struct irq_handler_data *data,
|
|
|
|
u32 devhandle, unsigned int devino)
|
|
|
|
{
|
|
|
|
unsigned long sysino;
|
2007-06-13 14:01:04 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
sysino = sun4v_devino_to_sysino(devhandle, devino);
|
|
|
|
data->sysino = sysino;
|
|
|
|
}
|
2007-06-13 14:01:04 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static unsigned int sysino_build_irq(u32 devhandle, unsigned int devino,
|
|
|
|
struct irq_chip *chip)
|
|
|
|
{
|
|
|
|
unsigned int irq;
|
2007-06-13 14:01:04 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
irq = sun4v_build_common(devhandle, devino, sysino_handler_data, chip);
|
|
|
|
if (!irq)
|
|
|
|
goto out;
|
2007-10-14 11:51:37 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
sysino_set_bucket(irq);
|
|
|
|
out:
|
|
|
|
return irq;
|
|
|
|
}
|
2007-06-13 14:01:04 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static int sun4v_build_sysino(u32 devhandle, unsigned int devino)
|
|
|
|
{
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
irq = sysino_exists(devhandle, devino);
|
|
|
|
if (irq)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
irq = sysino_build_irq(devhandle, devino, &sun4v_irq);
|
|
|
|
out:
|
2011-01-22 18:32:19 +07:00
|
|
|
return irq;
|
2007-06-13 14:01:04 +07:00
|
|
|
}
|
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino)
|
2006-06-20 15:23:32 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned int irq;
|
2006-02-15 16:18:19 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
if (sun4v_cookie_only_virqs())
|
|
|
|
irq = sun4v_build_cookie(devhandle, devino);
|
|
|
|
else
|
|
|
|
irq = sun4v_build_sysino(devhandle, devino);
|
2006-06-20 15:20:30 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino)
|
|
|
|
{
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
irq = cookie_build_irq(devhandle, devino, &sun4v_virq);
|
|
|
|
if (!irq)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* This is borrowed from the original function.
|
|
|
|
*/
|
|
|
|
irq_set_status_flags(irq, IRQ_NOAUTOEN);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return irq;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-08-13 08:33:56 +07:00
|
|
|
void *hardirq_stack[NR_CPUS];
|
|
|
|
void *softirq_stack[NR_CPUS];
|
|
|
|
|
2011-01-22 18:32:15 +07:00
|
|
|
void __irq_entry handler_irq(int pil, struct pt_regs *regs)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-14 11:42:46 +07:00
|
|
|
unsigned long pstate, bucket_pa;
|
2006-10-08 19:23:28 +07:00
|
|
|
struct pt_regs *old_regs;
|
2008-08-13 08:33:56 +07:00
|
|
|
void *orig_sp;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-01-22 18:32:15 +07:00
|
|
|
clear_softint(1 << pil);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-08 19:23:28 +07:00
|
|
|
old_regs = set_irq_regs(regs);
|
2005-04-17 05:20:36 +07:00
|
|
|
irq_enter();
|
|
|
|
|
2007-10-12 16:59:40 +07:00
|
|
|
/* Grab an atomic snapshot of the pending IVECs. */
|
|
|
|
__asm__ __volatile__("rdpr %%pstate, %0\n\t"
|
|
|
|
"wrpr %0, %3, %%pstate\n\t"
|
|
|
|
"ldx [%2], %1\n\t"
|
|
|
|
"stx %%g0, [%2]\n\t"
|
|
|
|
"wrpr %0, 0x0, %%pstate\n\t"
|
2007-10-14 11:42:46 +07:00
|
|
|
: "=&r" (pstate), "=&r" (bucket_pa)
|
|
|
|
: "r" (irq_work_pa(smp_processor_id())),
|
2007-10-12 16:59:40 +07:00
|
|
|
"i" (PSTATE_IE)
|
|
|
|
: "memory");
|
|
|
|
|
2008-08-13 08:33:56 +07:00
|
|
|
orig_sp = set_hardirq_stack();
|
|
|
|
|
2007-10-14 11:42:46 +07:00
|
|
|
while (bucket_pa) {
|
|
|
|
unsigned long next_pa;
|
2011-01-22 18:32:19 +07:00
|
|
|
unsigned int irq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-14 13:03:21 +07:00
|
|
|
next_pa = bucket_get_chain_pa(bucket_pa);
|
2011-01-22 18:32:19 +07:00
|
|
|
irq = bucket_get_irq(bucket_pa);
|
2007-10-14 13:03:21 +07:00
|
|
|
bucket_clear_chain_pa(bucket_pa);
|
2006-06-20 15:20:00 +07:00
|
|
|
|
2011-03-24 15:03:45 +07:00
|
|
|
generic_handle_irq(irq);
|
2007-10-14 11:42:46 +07:00
|
|
|
|
|
|
|
bucket_pa = next_pa;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-20 15:23:32 +07:00
|
|
|
|
2008-08-13 08:33:56 +07:00
|
|
|
restore_hardirq_stack(orig_sp);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
irq_exit();
|
2006-10-08 19:23:28 +07:00
|
|
|
set_irq_regs(old_regs);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2013-09-05 20:49:45 +07:00
|
|
|
void do_softirq_own_stack(void)
|
2008-08-13 08:33:56 +07:00
|
|
|
{
|
2013-09-05 20:49:45 +07:00
|
|
|
void *orig_sp, *sp = softirq_stack[smp_processor_id()];
|
2008-08-13 08:33:56 +07:00
|
|
|
|
2013-09-05 20:49:45 +07:00
|
|
|
sp += THREAD_SIZE - 192 - STACK_BIAS;
|
2008-08-13 08:33:56 +07:00
|
|
|
|
2013-09-05 20:49:45 +07:00
|
|
|
__asm__ __volatile__("mov %%sp, %0\n\t"
|
|
|
|
"mov %1, %%sp"
|
|
|
|
: "=&r" (orig_sp)
|
|
|
|
: "r" (sp));
|
|
|
|
__do_softirq();
|
|
|
|
__asm__ __volatile__("mov %0, %%sp"
|
|
|
|
: : "r" (orig_sp));
|
2008-08-13 08:33:56 +07:00
|
|
|
}
|
|
|
|
|
2007-07-16 17:49:40 +07:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
void fixup_irqs(void)
|
|
|
|
{
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
for (irq = 0; irq < NR_IRQS; irq++) {
|
2011-03-24 23:57:12 +07:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2014-09-26 02:25:03 +07:00
|
|
|
struct irq_data *data;
|
2007-07-16 17:49:40 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
data = irq_desc_get_irq_data(desc);
|
2011-03-24 23:57:12 +07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
if (desc->action && !irqd_is_per_cpu(data)) {
|
2011-01-22 18:32:18 +07:00
|
|
|
if (data->chip->irq_set_affinity)
|
|
|
|
data->chip->irq_set_affinity(data,
|
2011-03-24 23:57:12 +07:00
|
|
|
data->affinity,
|
|
|
|
false);
|
2007-07-16 17:49:40 +07:00
|
|
|
}
|
2011-03-24 23:57:12 +07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2007-07-16 17:49:40 +07:00
|
|
|
}
|
2008-09-09 07:21:07 +07:00
|
|
|
|
|
|
|
tick_ops->disable_irq();
|
2007-07-16 17:49:40 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-07-25 09:36:13 +07:00
|
|
|
struct sun5_timer {
|
|
|
|
u64 count0;
|
|
|
|
u64 limit0;
|
|
|
|
u64 count1;
|
|
|
|
u64 limit1;
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-25 09:36:13 +07:00
|
|
|
static struct sun5_timer *prom_timers;
|
2005-04-17 05:20:36 +07:00
|
|
|
static u64 prom_limit0, prom_limit1;
|
|
|
|
|
|
|
|
static void map_prom_timers(void)
|
|
|
|
{
|
2006-06-23 10:21:22 +07:00
|
|
|
struct device_node *dp;
|
2007-04-24 05:53:27 +07:00
|
|
|
const unsigned int *addr;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* PROM timer node hangs out in the top level of device siblings... */
|
2006-06-23 10:21:22 +07:00
|
|
|
dp = of_find_node_by_path("/");
|
|
|
|
dp = dp->child;
|
|
|
|
while (dp) {
|
|
|
|
if (!strcmp(dp->name, "counter-timer"))
|
|
|
|
break;
|
|
|
|
dp = dp->sibling;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Assume if node is not present, PROM uses different tick mechanism
|
|
|
|
* which we should not care about.
|
|
|
|
*/
|
2006-06-23 10:21:22 +07:00
|
|
|
if (!dp) {
|
2005-04-17 05:20:36 +07:00
|
|
|
prom_timers = (struct sun5_timer *) 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If PROM is really using this, it must be mapped by him. */
|
2006-06-23 10:21:22 +07:00
|
|
|
addr = of_get_property(dp, "address", NULL);
|
|
|
|
if (!addr) {
|
2005-04-17 05:20:36 +07:00
|
|
|
prom_printf("PROM does not have timer mapped, trying to continue.\n");
|
|
|
|
prom_timers = (struct sun5_timer *) 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
prom_timers = (struct sun5_timer *) ((unsigned long)addr[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void kill_prom_timer(void)
|
|
|
|
{
|
|
|
|
if (!prom_timers)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Save them away for later. */
|
|
|
|
prom_limit0 = prom_timers->limit0;
|
|
|
|
prom_limit1 = prom_timers->limit1;
|
|
|
|
|
2012-05-12 14:35:45 +07:00
|
|
|
/* Just as in sun4c PROM uses timer which ticks at IRQ 14.
|
2005-04-17 05:20:36 +07:00
|
|
|
* We turn both off here just to be paranoid.
|
|
|
|
*/
|
|
|
|
prom_timers->limit0 = 0;
|
|
|
|
prom_timers->limit1 = 0;
|
|
|
|
|
|
|
|
/* Wheee, eat the interrupt packet too... */
|
|
|
|
__asm__ __volatile__(
|
|
|
|
" mov 0x40, %%g2\n"
|
|
|
|
" ldxa [%%g0] %0, %%g1\n"
|
|
|
|
" ldxa [%%g2] %1, %%g1\n"
|
|
|
|
" stxa %%g0, [%%g0] %0\n"
|
|
|
|
" membar #Sync\n"
|
|
|
|
: /* no outputs */
|
|
|
|
: "i" (ASI_INTR_RECEIVE), "i" (ASI_INTR_R)
|
|
|
|
: "g1", "g2");
|
|
|
|
}
|
|
|
|
|
2008-09-17 01:44:00 +07:00
|
|
|
void notrace init_irqwork_curcpu(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int cpu = hard_smp_processor_id();
|
|
|
|
|
2007-10-14 11:42:46 +07:00
|
|
|
trap_block[cpu].irq_worklist_pa = 0UL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-05-26 05:49:59 +07:00
|
|
|
/* Please be very careful with register_one_mondo() and
|
|
|
|
* sun4v_register_mondo_queues().
|
|
|
|
*
|
|
|
|
* On SMP this gets invoked from the CPU trampoline before
|
|
|
|
* the cpu has fully taken over the trap table from OBP,
|
|
|
|
* and it's kernel stack + %g6 thread register state is
|
|
|
|
* not fully cooked yet.
|
|
|
|
*
|
|
|
|
* Therefore you cannot make any OBP calls, not even prom_printf,
|
|
|
|
* from these two routines.
|
|
|
|
*/
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-18 02:43:14 +07:00
|
|
|
static void notrace register_one_mondo(unsigned long paddr, unsigned long type,
|
|
|
|
unsigned long qmask)
|
2006-02-08 15:08:23 +07:00
|
|
|
{
|
2007-05-26 05:49:59 +07:00
|
|
|
unsigned long num_entries = (qmask + 1) / 64;
|
2006-02-17 05:26:53 +07:00
|
|
|
unsigned long status;
|
|
|
|
|
|
|
|
status = sun4v_cpu_qconf(type, paddr, num_entries);
|
|
|
|
if (status != HV_EOK) {
|
|
|
|
prom_printf("SUN4V: sun4v_cpu_qconf(%lu:%lx:%lu) failed, "
|
|
|
|
"err %lu\n", type, paddr, num_entries, status);
|
2006-02-08 15:08:23 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-18 02:43:14 +07:00
|
|
|
void notrace sun4v_register_mondo_queues(int this_cpu)
|
2006-02-08 17:53:50 +07:00
|
|
|
{
|
2006-02-12 14:07:13 +07:00
|
|
|
struct trap_per_cpu *tb = &trap_block[this_cpu];
|
|
|
|
|
2007-05-26 05:49:59 +07:00
|
|
|
register_one_mondo(tb->cpu_mondo_pa, HV_CPU_QUEUE_CPU_MONDO,
|
|
|
|
tb->cpu_mondo_qmask);
|
|
|
|
register_one_mondo(tb->dev_mondo_pa, HV_CPU_QUEUE_DEVICE_MONDO,
|
|
|
|
tb->dev_mondo_qmask);
|
|
|
|
register_one_mondo(tb->resum_mondo_pa, HV_CPU_QUEUE_RES_ERROR,
|
|
|
|
tb->resum_qmask);
|
|
|
|
register_one_mondo(tb->nonresum_mondo_pa, HV_CPU_QUEUE_NONRES_ERROR,
|
|
|
|
tb->nonresum_qmask);
|
2006-02-12 14:07:13 +07:00
|
|
|
}
|
|
|
|
|
2009-06-26 09:00:47 +07:00
|
|
|
/* Each queue region must be a power of 2 multiple of 64 bytes in
|
|
|
|
* size. The base real address must be aligned to the size of the
|
|
|
|
* region. Thus, an 8KB queue must be 8KB aligned, for example.
|
|
|
|
*/
|
|
|
|
static void __init alloc_one_queue(unsigned long *pa_ptr, unsigned long qmask)
|
2006-02-12 14:07:13 +07:00
|
|
|
{
|
2007-05-26 05:49:59 +07:00
|
|
|
unsigned long size = PAGE_ALIGN(qmask + 1);
|
2009-06-26 09:00:47 +07:00
|
|
|
unsigned long order = get_order(size);
|
|
|
|
unsigned long p;
|
2006-02-08 17:53:50 +07:00
|
|
|
|
2009-06-26 09:00:47 +07:00
|
|
|
p = __get_free_pages(GFP_KERNEL, order);
|
2007-05-26 05:49:59 +07:00
|
|
|
if (!p) {
|
2009-06-26 09:00:47 +07:00
|
|
|
prom_printf("SUN4V: Error, cannot allocate queue.\n");
|
2006-02-08 17:53:50 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
2007-05-26 05:49:59 +07:00
|
|
|
*pa_ptr = __pa(p);
|
2006-02-08 17:53:50 +07:00
|
|
|
}
|
|
|
|
|
2007-08-09 07:32:33 +07:00
|
|
|
static void __init init_cpu_send_mondo_info(struct trap_per_cpu *tb)
|
2006-02-09 07:41:20 +07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2009-06-26 09:00:47 +07:00
|
|
|
unsigned long page;
|
2006-02-09 07:41:20 +07:00
|
|
|
|
|
|
|
BUILD_BUG_ON((NR_CPUS * sizeof(u16)) > (PAGE_SIZE - 64));
|
|
|
|
|
2009-06-26 09:00:47 +07:00
|
|
|
page = get_zeroed_page(GFP_KERNEL);
|
2006-02-09 07:41:20 +07:00
|
|
|
if (!page) {
|
|
|
|
prom_printf("SUN4V: Error, cannot allocate cpu mondo page.\n");
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
|
|
|
tb->cpu_mondo_block_pa = __pa(page);
|
|
|
|
tb->cpu_list_pa = __pa(page + 64);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-08-09 07:32:33 +07:00
|
|
|
/* Allocate mondo and error queues for all possible cpus. */
|
|
|
|
static void __init sun4v_init_mondo_queues(void)
|
2006-02-08 15:08:23 +07:00
|
|
|
{
|
2007-08-09 07:32:33 +07:00
|
|
|
int cpu;
|
2006-02-08 15:08:23 +07:00
|
|
|
|
2007-08-09 07:32:33 +07:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
struct trap_per_cpu *tb = &trap_block[cpu];
|
2006-02-09 07:41:20 +07:00
|
|
|
|
2009-06-26 09:00:47 +07:00
|
|
|
alloc_one_queue(&tb->cpu_mondo_pa, tb->cpu_mondo_qmask);
|
|
|
|
alloc_one_queue(&tb->dev_mondo_pa, tb->dev_mondo_qmask);
|
|
|
|
alloc_one_queue(&tb->resum_mondo_pa, tb->resum_qmask);
|
|
|
|
alloc_one_queue(&tb->resum_kernel_buf_pa, tb->resum_qmask);
|
|
|
|
alloc_one_queue(&tb->nonresum_mondo_pa, tb->nonresum_qmask);
|
|
|
|
alloc_one_queue(&tb->nonresum_kernel_buf_pa,
|
|
|
|
tb->nonresum_qmask);
|
2008-08-05 06:13:51 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init init_send_mondo_info(void)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
struct trap_per_cpu *tb = &trap_block[cpu];
|
2006-02-09 07:41:20 +07:00
|
|
|
|
2007-08-09 07:32:33 +07:00
|
|
|
init_cpu_send_mondo_info(tb);
|
[SPARC64]: Get SUN4V SMP working.
The sibling cpu bringup is extremely fragile. We can only
perform the most basic calls until we take over the trap
table from the firmware/hypervisor on the new cpu.
This means no accesses to %g4, %g5, %g6 since those can't be
TLB translated without our trap handlers.
In order to achieve this:
1) Change sun4v_init_mondo_queues() so that it can operate in
several modes.
It can allocate the queues, or install them in the current
processor, or both.
The boot cpu does both in it's call early on.
Later, the boot cpu allocates the sibling cpu queue, starts
the sibling cpu, then the sibling cpu loads them in.
2) init_cur_cpu_trap() is changed to take the current_thread_info()
as an argument instead of reading %g6 directly on the current
cpu.
3) Create a trampoline stack for the sibling cpus. We do our basic
kernel calls using this stack, which is locked into the kernel
image, then go to our proper thread stack after taking over the
trap table.
4) While we are in this delicate startup state, we put 0xdeadbeef
into %g4/%g5/%g6 in order to catch accidental accesses.
5) On the final prom_set_trap_table*() call, we put &init_thread_union
into %g6. This is a hack to make prom_world(0) work. All that
wants to do is restore the %asi register using
get_thread_current_ds().
Longer term we should just do the OBP calls to set the trap table by
hand just like we do for everything else. This would avoid that silly
prom_world(0) issue, then we can remove the init_thread_union hack.
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-02-17 16:29:17 +07:00
|
|
|
}
|
2006-02-08 15:08:23 +07:00
|
|
|
}
|
|
|
|
|
2006-06-20 15:23:32 +07:00
|
|
|
static struct irqaction timer_irq_action = {
|
|
|
|
.name = "timer",
|
|
|
|
};
|
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
static void __init irq_ivector_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2014-09-26 02:25:03 +07:00
|
|
|
unsigned long size, order;
|
|
|
|
unsigned int ivecs;
|
2007-10-14 11:43:31 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
/* If we are doing cookie only VIRQs then we do not need the ivector
|
|
|
|
* table to process interrupts.
|
|
|
|
*/
|
|
|
|
if (sun4v_cookie_only_virqs())
|
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-09-26 02:25:03 +07:00
|
|
|
ivecs = size_nr_ivec();
|
|
|
|
size = sizeof(struct ino_bucket) * ivecs;
|
|
|
|
order = get_order(size);
|
|
|
|
ivector_table = (struct ino_bucket *)
|
|
|
|
__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
|
2007-10-14 11:43:31 +07:00
|
|
|
if (!ivector_table) {
|
|
|
|
prom_printf("Fatal error, cannot allocate ivector_table\n");
|
|
|
|
prom_halt();
|
|
|
|
}
|
2007-10-14 13:03:21 +07:00
|
|
|
__flush_dcache_range((unsigned long) ivector_table,
|
|
|
|
((unsigned long) ivector_table) + size);
|
2007-10-14 11:43:31 +07:00
|
|
|
|
|
|
|
ivector_table_pa = __pa(ivector_table);
|
2014-09-26 02:25:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Only invoked on boot processor.*/
|
|
|
|
void __init init_IRQ(void)
|
|
|
|
{
|
|
|
|
irq_init_hv();
|
|
|
|
irq_ivector_init();
|
|
|
|
map_prom_timers();
|
|
|
|
kill_prom_timer();
|
2007-10-14 11:42:46 +07:00
|
|
|
|
2006-02-08 15:08:23 +07:00
|
|
|
if (tlb_type == hypervisor)
|
2007-08-09 07:32:33 +07:00
|
|
|
sun4v_init_mondo_queues();
|
2006-02-08 15:08:23 +07:00
|
|
|
|
2008-08-05 06:13:51 +07:00
|
|
|
init_send_mondo_info();
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
/* Load up the boot cpu's entries. */
|
|
|
|
sun4v_register_mondo_queues(hard_smp_processor_id());
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* We need to clear any IRQ's pending in the soft interrupt
|
|
|
|
* registers, a spurious one could be left around from the
|
|
|
|
* PROM timer which we just disabled.
|
|
|
|
*/
|
|
|
|
clear_softint(get_softint());
|
|
|
|
|
|
|
|
/* Now that ivector table is initialized, it is safe
|
|
|
|
* to receive IRQ vector traps. We will normally take
|
|
|
|
* one or two right now, in case some device PROM used
|
|
|
|
* to boot us wants to speak to us. We just ignore them.
|
|
|
|
*/
|
|
|
|
__asm__ __volatile__("rdpr %%pstate, %%g1\n\t"
|
|
|
|
"or %%g1, %0, %%g1\n\t"
|
|
|
|
"wrpr %%g1, 0x0, %%pstate"
|
|
|
|
: /* No outputs */
|
|
|
|
: "i" (PSTATE_IE)
|
|
|
|
: "g1");
|
|
|
|
|
2011-03-24 23:57:12 +07:00
|
|
|
irq_to_desc(0)->action = &timer_irq_action;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|