2018-07-30 14:11:32 +00:00
|
|
|
/*
|
|
|
|
|
* QEMU PowerPC sPAPR IRQ interface
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2018, IBM Corporation.
|
|
|
|
|
*
|
|
|
|
|
* This code is licensed under the GPL version 2 or later. See the
|
|
|
|
|
* COPYING file in the top-level directory.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
|
#include "qemu/log.h"
|
|
|
|
|
#include "qemu/error-report.h"
|
|
|
|
|
#include "qapi/error.h"
|
2019-08-12 05:23:42 +00:00
|
|
|
#include "hw/irq.h"
|
2018-07-30 14:11:32 +00:00
|
|
|
#include "hw/ppc/spapr.h"
|
2019-01-17 07:53:26 +00:00
|
|
|
#include "hw/ppc/spapr_cpu_core.h"
|
2018-12-11 22:38:12 +00:00
|
|
|
#include "hw/ppc/spapr_xive.h"
|
2018-07-30 14:11:32 +00:00
|
|
|
#include "hw/ppc/xics.h"
|
2019-01-10 08:18:47 +00:00
|
|
|
#include "hw/ppc/xics_spapr.h"
|
2019-08-12 05:23:51 +00:00
|
|
|
#include "hw/qdev-properties.h"
|
2019-03-28 10:00:44 +00:00
|
|
|
#include "cpu-models.h"
|
2018-07-30 14:11:33 +00:00
|
|
|
#include "sysemu/kvm.h"
|
|
|
|
|
|
|
|
|
|
#include "trace.h"
|
2018-07-30 14:11:32 +00:00
|
|
|
|
2019-09-24 06:25:08 +00:00
|
|
|
static const TypeInfo spapr_intc_info = {
|
|
|
|
|
.name = TYPE_SPAPR_INTC,
|
|
|
|
|
.parent = TYPE_INTERFACE,
|
|
|
|
|
.class_size = sizeof(SpaprInterruptControllerClass),
|
|
|
|
|
};
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis)
|
2018-07-30 14:11:32 +00:00
|
|
|
{
|
|
|
|
|
spapr->irq_map_nr = nr_msis;
|
|
|
|
|
spapr->irq_map = bitmap_new(spapr->irq_map_nr);
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
|
2018-07-30 14:11:32 +00:00
|
|
|
Error **errp)
|
|
|
|
|
{
|
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The 'align_mask' parameter of bitmap_find_next_zero_area()
|
|
|
|
|
* should be one less than a power of 2; 0 means no
|
|
|
|
|
* alignment. Adapt the 'align' value of the former allocator
|
|
|
|
|
* to fit the requirements of bitmap_find_next_zero_area()
|
|
|
|
|
*/
|
|
|
|
|
align -= 1;
|
|
|
|
|
|
|
|
|
|
irq = bitmap_find_next_zero_area(spapr->irq_map, spapr->irq_map_nr, 0, num,
|
|
|
|
|
align);
|
|
|
|
|
if (irq == spapr->irq_map_nr) {
|
|
|
|
|
error_setg(errp, "can't find a free %d-IRQ block", num);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bitmap_set(spapr->irq_map, irq, num);
|
|
|
|
|
|
|
|
|
|
return irq + SPAPR_IRQ_MSI;
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num)
|
2018-07-30 14:11:32 +00:00
|
|
|
{
|
|
|
|
|
bitmap_clear(spapr->irq_map, irq - SPAPR_IRQ_MSI, num);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-14 16:59:20 +00:00
|
|
|
static void spapr_irq_init_kvm(SpaprMachineState *spapr,
|
2019-05-13 08:42:42 +00:00
|
|
|
SpaprIrq *irq, Error **errp)
|
2018-07-30 14:11:33 +00:00
|
|
|
{
|
|
|
|
|
MachineState *machine = MACHINE(spapr);
|
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
2019-05-13 08:42:42 +00:00
|
|
|
if (kvm_enabled() && machine_kernel_irqchip_allowed(machine)) {
|
|
|
|
|
irq->init_kvm(spapr, &local_err);
|
|
|
|
|
if (local_err && machine_kernel_irqchip_required(machine)) {
|
2018-07-30 14:11:33 +00:00
|
|
|
error_prepend(&local_err,
|
|
|
|
|
"kernel_irqchip requested but unavailable: ");
|
2019-03-21 14:49:11 +00:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
2018-07-30 14:11:33 +00:00
|
|
|
}
|
2019-05-13 08:42:42 +00:00
|
|
|
|
|
|
|
|
if (!local_err) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We failed to initialize the KVM device, fallback to
|
|
|
|
|
* emulated mode
|
|
|
|
|
*/
|
|
|
|
|
error_prepend(&local_err, "kernel_irqchip allowed but unavailable: ");
|
2019-07-24 16:57:14 +00:00
|
|
|
error_append_hint(&local_err, "Falling back to kernel-irqchip=off\n");
|
2019-05-13 08:42:42 +00:00
|
|
|
warn_report_err(local_err);
|
2018-07-30 14:11:33 +00:00
|
|
|
}
|
2019-05-13 08:42:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* XICS IRQ backend.
|
|
|
|
|
*/
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
|
2018-12-11 22:38:16 +00:00
|
|
|
{
|
2019-02-15 11:40:41 +00:00
|
|
|
if (!kvm_irqchip_in_kernel()) {
|
2018-12-11 22:38:16 +00:00
|
|
|
CPUState *cs;
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
2019-01-17 07:53:26 +00:00
|
|
|
icp_resend(spapr_cpu_state(cpu)->icp);
|
2018-12-11 22:38:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
|
2019-01-02 05:57:42 +00:00
|
|
|
{
|
2019-05-13 08:42:45 +00:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
2019-06-14 16:59:20 +00:00
|
|
|
spapr_irq_init_kvm(spapr, &spapr_irq_xics, &local_err);
|
2019-05-13 08:42:45 +00:00
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-01-02 05:57:42 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-13 08:42:42 +00:00
|
|
|
static void spapr_irq_init_kvm_xics(SpaprMachineState *spapr, Error **errp)
|
|
|
|
|
{
|
|
|
|
|
if (kvm_enabled()) {
|
2019-09-26 13:23:51 +00:00
|
|
|
xics_kvm_connect(SPAPR_INTC(spapr->ics), errp);
|
2019-05-13 08:42:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
SpaprIrq spapr_irq_xics = {
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
.nr_xirqs = SPAPR_NR_XIRQS,
|
|
|
|
|
.nr_msis = SPAPR_NR_MSIS,
|
2019-09-25 05:12:07 +00:00
|
|
|
.xics = true,
|
|
|
|
|
.xive = false,
|
2018-07-30 14:11:33 +00:00
|
|
|
|
2018-12-11 22:38:16 +00:00
|
|
|
.post_load = spapr_irq_post_load_xics,
|
2019-01-02 05:57:42 +00:00
|
|
|
.reset = spapr_irq_reset_xics,
|
2019-05-13 08:42:42 +00:00
|
|
|
.init_kvm = spapr_irq_init_kvm_xics,
|
2018-07-30 14:11:33 +00:00
|
|
|
};
|
|
|
|
|
|
2018-12-11 22:38:12 +00:00
|
|
|
/*
|
|
|
|
|
* XIVE IRQ backend.
|
|
|
|
|
*/
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
|
2018-12-11 22:38:16 +00:00
|
|
|
{
|
2019-05-13 08:42:37 +00:00
|
|
|
return spapr_xive_post_load(spapr->xive, version_id);
|
2018-12-11 22:38:16 +00:00
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
|
2018-12-11 22:38:17 +00:00
|
|
|
{
|
|
|
|
|
CPUState *cs;
|
2019-05-13 08:42:45 +00:00
|
|
|
Error *local_err = NULL;
|
2018-12-11 22:38:17 +00:00
|
|
|
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
|
|
|
|
|
|
|
|
/* (TCG) Set the OS CAM line of the thread interrupt context. */
|
2019-01-17 07:53:26 +00:00
|
|
|
spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
|
2018-12-11 22:38:17 +00:00
|
|
|
}
|
2019-01-02 05:57:43 +00:00
|
|
|
|
2019-06-14 16:59:20 +00:00
|
|
|
spapr_irq_init_kvm(spapr, &spapr_irq_xive, &local_err);
|
2019-05-13 08:42:45 +00:00
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-02 05:57:43 +00:00
|
|
|
/* Activate the XIVE MMIOs */
|
|
|
|
|
spapr_xive_mmio_set_enabled(spapr->xive, true);
|
2018-12-11 22:38:17 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-13 08:42:42 +00:00
|
|
|
static void spapr_irq_init_kvm_xive(SpaprMachineState *spapr, Error **errp)
|
|
|
|
|
{
|
|
|
|
|
if (kvm_enabled()) {
|
2019-09-26 13:23:51 +00:00
|
|
|
kvmppc_xive_connect(SPAPR_INTC(spapr->xive), errp);
|
2019-05-13 08:42:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
SpaprIrq spapr_irq_xive = {
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
.nr_xirqs = SPAPR_NR_XIRQS,
|
|
|
|
|
.nr_msis = SPAPR_NR_MSIS,
|
2019-09-25 05:12:07 +00:00
|
|
|
.xics = false,
|
|
|
|
|
.xive = true,
|
2018-12-11 22:38:12 +00:00
|
|
|
|
2018-12-11 22:38:16 +00:00
|
|
|
.post_load = spapr_irq_post_load_xive,
|
2018-12-11 22:38:17 +00:00
|
|
|
.reset = spapr_irq_reset_xive,
|
2019-05-13 08:42:42 +00:00
|
|
|
.init_kvm = spapr_irq_init_kvm_xive,
|
2018-12-11 22:38:12 +00:00
|
|
|
};
|
|
|
|
|
|
2019-01-02 05:57:42 +00:00
|
|
|
/*
|
|
|
|
|
* Dual XIVE and XICS IRQ backend.
|
|
|
|
|
*
|
|
|
|
|
* Both interrupt mode, XIVE and XICS, objects are created but the
|
|
|
|
|
* machine starts in legacy interrupt mode (XICS). It can be changed
|
|
|
|
|
* by the CAS negotiation process and, in that case, the new mode is
|
|
|
|
|
* activated after an extra machine reset.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Returns the sPAPR IRQ backend negotiated by CAS. XICS is the
|
|
|
|
|
* default.
|
|
|
|
|
*/
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
|
2019-01-02 05:57:42 +00:00
|
|
|
{
|
|
|
|
|
return spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT) ?
|
|
|
|
|
&spapr_irq_xive : &spapr_irq_xics;
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
|
2019-01-02 05:57:42 +00:00
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Force a reset of the XIVE backend after migration. The machine
|
|
|
|
|
* defaults to XICS at startup.
|
|
|
|
|
*/
|
|
|
|
|
if (spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT)) {
|
2019-05-13 08:42:45 +00:00
|
|
|
if (kvm_irqchip_in_kernel()) {
|
2019-09-26 13:23:51 +00:00
|
|
|
xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
|
2019-05-13 08:42:45 +00:00
|
|
|
}
|
2019-01-02 05:57:42 +00:00
|
|
|
spapr_irq_xive.reset(spapr, &error_fatal);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return spapr_irq_current(spapr)->post_load(spapr, version_id);
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
|
2019-01-02 05:57:42 +00:00
|
|
|
{
|
2019-01-02 05:57:43 +00:00
|
|
|
/*
|
|
|
|
|
* Deactivate the XIVE MMIOs. The XIVE backend will reenable them
|
|
|
|
|
* if selected.
|
|
|
|
|
*/
|
|
|
|
|
spapr_xive_mmio_set_enabled(spapr->xive, false);
|
|
|
|
|
|
2019-05-13 08:42:45 +00:00
|
|
|
/* Destroy all KVM devices */
|
|
|
|
|
if (kvm_irqchip_in_kernel()) {
|
2019-09-26 13:23:51 +00:00
|
|
|
xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
|
|
|
|
|
kvmppc_xive_disconnect(SPAPR_INTC(spapr->xive));
|
2019-05-13 08:42:45 +00:00
|
|
|
}
|
|
|
|
|
|
2019-01-02 05:57:42 +00:00
|
|
|
spapr_irq_current(spapr)->reset(spapr, errp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Define values in sync with the XIVE and XICS backend
|
|
|
|
|
*/
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
SpaprIrq spapr_irq_dual = {
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
.nr_xirqs = SPAPR_NR_XIRQS,
|
|
|
|
|
.nr_msis = SPAPR_NR_MSIS,
|
2019-09-25 05:12:07 +00:00
|
|
|
.xics = true,
|
|
|
|
|
.xive = true,
|
2019-01-02 05:57:42 +00:00
|
|
|
|
|
|
|
|
.post_load = spapr_irq_post_load_dual,
|
|
|
|
|
.reset = spapr_irq_reset_dual,
|
2019-05-13 08:42:42 +00:00
|
|
|
.init_kvm = NULL, /* should not be used */
|
2019-01-02 05:57:42 +00:00
|
|
|
};
|
|
|
|
|
|
2019-03-28 10:00:44 +00:00
|
|
|
|
2019-09-30 02:20:47 +00:00
|
|
|
static int spapr_irq_check(SpaprMachineState *spapr, Error **errp)
|
2019-03-28 10:00:44 +00:00
|
|
|
{
|
|
|
|
|
MachineState *machine = MACHINE(spapr);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Sanity checks on non-P9 machines. On these, XIVE is not
|
|
|
|
|
* advertised, see spapr_dt_ov5_platform_support()
|
|
|
|
|
*/
|
|
|
|
|
if (!ppc_type_check_compat(machine->cpu_type, CPU_POWERPC_LOGICAL_3_00,
|
|
|
|
|
0, spapr->max_compat_pvr)) {
|
|
|
|
|
/*
|
|
|
|
|
* If the 'dual' interrupt mode is selected, force XICS as CAS
|
|
|
|
|
* negotiation is useless.
|
|
|
|
|
*/
|
|
|
|
|
if (spapr->irq == &spapr_irq_dual) {
|
|
|
|
|
spapr->irq = &spapr_irq_xics;
|
2019-09-30 02:20:47 +00:00
|
|
|
return 0;
|
2019-03-28 10:00:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Non-P9 machines using only XIVE is a bogus setup. We have two
|
|
|
|
|
* scenarios to take into account because of the compat mode:
|
|
|
|
|
*
|
|
|
|
|
* 1. POWER7/8 machines should fail to init later on when creating
|
|
|
|
|
* the XIVE interrupt presenters because a POWER9 exception
|
|
|
|
|
* model is required.
|
|
|
|
|
|
|
|
|
|
* 2. POWER9 machines using the POWER8 compat mode won't fail and
|
|
|
|
|
* will let the OS boot with a partial XIVE setup : DT
|
|
|
|
|
* properties but no hcalls.
|
|
|
|
|
*
|
|
|
|
|
* To cover both and not confuse the OS, add an early failure in
|
|
|
|
|
* QEMU.
|
|
|
|
|
*/
|
|
|
|
|
if (spapr->irq == &spapr_irq_xive) {
|
|
|
|
|
error_setg(errp, "XIVE-only machines require a POWER9 CPU");
|
2019-09-30 02:20:47 +00:00
|
|
|
return -1;
|
2019-03-28 10:00:44 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-06-13 16:45:05 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* On a POWER9 host, some older KVM XICS devices cannot be destroyed and
|
|
|
|
|
* re-created. Detect that early to avoid QEMU to exit later when the
|
|
|
|
|
* guest reboots.
|
|
|
|
|
*/
|
|
|
|
|
if (kvm_enabled() &&
|
|
|
|
|
spapr->irq == &spapr_irq_dual &&
|
|
|
|
|
machine_kernel_irqchip_required(machine) &&
|
|
|
|
|
xics_kvm_has_broken_disconnect(spapr)) {
|
|
|
|
|
error_setg(errp, "KVM is too old to support ic-mode=dual,kernel-irqchip=on");
|
2019-09-30 02:20:47 +00:00
|
|
|
return -1;
|
2019-06-13 16:45:05 +00:00
|
|
|
}
|
2019-09-30 02:20:47 +00:00
|
|
|
|
|
|
|
|
return 0;
|
2019-03-28 10:00:44 +00:00
|
|
|
}
|
|
|
|
|
|
2018-07-30 14:11:33 +00:00
|
|
|
/*
|
|
|
|
|
* sPAPR IRQ frontend routines for devices
|
|
|
|
|
*/
|
2019-09-26 04:11:23 +00:00
|
|
|
#define ALL_INTCS(spapr_) \
|
|
|
|
|
{ SPAPR_INTC((spapr_)->ics), SPAPR_INTC((spapr_)->xive), }
|
|
|
|
|
|
|
|
|
|
int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
|
|
|
|
|
PowerPCCPU *cpu, Error **errp)
|
|
|
|
|
{
|
|
|
|
|
SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
|
|
|
|
|
int i;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(intcs); i++) {
|
|
|
|
|
SpaprInterruptController *intc = intcs[i];
|
|
|
|
|
if (intc) {
|
|
|
|
|
SpaprInterruptControllerClass *sicc = SPAPR_INTC_GET_CLASS(intc);
|
|
|
|
|
rc = sicc->cpu_intc_create(intc, cpu, errp);
|
|
|
|
|
if (rc < 0) {
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-26 06:09:46 +00:00
|
|
|
static void spapr_set_irq(void *opaque, int irq, int level)
|
|
|
|
|
{
|
|
|
|
|
SpaprMachineState *spapr = SPAPR_MACHINE(opaque);
|
|
|
|
|
SpaprInterruptControllerClass *sicc
|
|
|
|
|
= SPAPR_INTC_GET_CLASS(spapr->active_intc);
|
|
|
|
|
|
|
|
|
|
sicc->set_irq(spapr->active_intc, irq, level);
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-26 06:12:05 +00:00
|
|
|
void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon)
|
|
|
|
|
{
|
|
|
|
|
SpaprInterruptControllerClass *sicc
|
|
|
|
|
= SPAPR_INTC_GET_CLASS(spapr->active_intc);
|
|
|
|
|
|
|
|
|
|
sicc->print_info(spapr->active_intc, mon);
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-30 02:35:06 +00:00
|
|
|
void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
|
|
|
|
|
void *fdt, uint32_t phandle)
|
|
|
|
|
{
|
|
|
|
|
SpaprInterruptControllerClass *sicc
|
|
|
|
|
= SPAPR_INTC_GET_CLASS(spapr->active_intc);
|
|
|
|
|
|
|
|
|
|
sicc->dt(spapr->active_intc, nr_servers, fdt, phandle);
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
|
2018-12-05 23:22:27 +00:00
|
|
|
{
|
spapr: Disallow unsupported kernel-irqchip settings
Split mode doesn't make sense on pseries, neither with XICS nor XIVE. But
passing kernel-irqchip=split silently behaves like kernel-irqchip=on.
Other architectures that support kernel-irqchip do terminate QEMU when
split mode is requested but not available though. Do the same with pseries
for consistency.
Similarly, passing kernel-irqchip=on,accel=tcg starts the machine with the
emulated interrupt controller, ie, behaves like kernel-irqchip=off. However,
when passing kernel-irqchip=on,accel=kvm, if we can't initialize the KVM
XICS for some reason, ie, xics_kvm_init() fails, then QEMU is terminated.
This is inconsistent. Terminate QEMU all the same when requesting the
in-kernel interrupt controller without KVM.
Signed-off-by: Greg Kurz <groug@kaod.org>
Message-Id: <154964986747.291716.2679312373018476920.stgit@bahia.lan>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-02-08 18:17:47 +00:00
|
|
|
MachineState *machine = MACHINE(spapr);
|
|
|
|
|
|
|
|
|
|
if (machine_kernel_irqchip_split(machine)) {
|
|
|
|
|
error_setg(errp, "kernel_irqchip split mode not supported on pseries");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!kvm_enabled() && machine_kernel_irqchip_required(machine)) {
|
|
|
|
|
error_setg(errp,
|
|
|
|
|
"kernel_irqchip requested but only available with KVM");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-30 02:20:47 +00:00
|
|
|
if (spapr_irq_check(spapr, errp) < 0) {
|
2019-03-28 10:00:44 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-05 23:22:27 +00:00
|
|
|
/* Initialize the MSI IRQ allocator. */
|
|
|
|
|
if (!SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
|
2018-12-17 22:34:43 +00:00
|
|
|
spapr_irq_msi_init(spapr, spapr->irq->nr_msis);
|
2018-12-05 23:22:27 +00:00
|
|
|
}
|
|
|
|
|
|
2019-09-30 02:24:43 +00:00
|
|
|
if (spapr->irq->xics) {
|
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
Object *obj;
|
|
|
|
|
|
|
|
|
|
obj = object_new(TYPE_ICS_SPAPR);
|
|
|
|
|
object_property_add_child(OBJECT(spapr), "ics", obj, &local_err);
|
|
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
object_property_add_const_link(obj, ICS_PROP_XICS, OBJECT(spapr),
|
|
|
|
|
&local_err);
|
|
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
object_property_set_int(obj, spapr->irq->nr_xirqs, "nr-irqs",
|
|
|
|
|
&local_err);
|
|
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
object_property_set_bool(obj, true, "realized", &local_err);
|
|
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spapr->ics = ICS_SPAPR(obj);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (spapr->irq->xive) {
|
|
|
|
|
uint32_t nr_servers = spapr_max_server_number(spapr);
|
|
|
|
|
DeviceState *dev;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
dev = qdev_create(NULL, TYPE_SPAPR_XIVE);
|
|
|
|
|
qdev_prop_set_uint32(dev, "nr-irqs",
|
|
|
|
|
spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE);
|
|
|
|
|
/*
|
|
|
|
|
* 8 XIVE END structures per CPU. One for each available
|
|
|
|
|
* priority
|
|
|
|
|
*/
|
|
|
|
|
qdev_prop_set_uint32(dev, "nr-ends", nr_servers << 3);
|
|
|
|
|
qdev_init_nofail(dev);
|
|
|
|
|
|
|
|
|
|
spapr->xive = SPAPR_XIVE(dev);
|
|
|
|
|
|
|
|
|
|
/* Enable the CPU IPIs */
|
|
|
|
|
for (i = 0; i < nr_servers; ++i) {
|
2019-09-26 04:31:13 +00:00
|
|
|
SpaprInterruptControllerClass *sicc
|
|
|
|
|
= SPAPR_INTC_GET_CLASS(spapr->xive);
|
|
|
|
|
|
|
|
|
|
if (sicc->claim_irq(SPAPR_INTC(spapr->xive), SPAPR_IRQ_IPI + i,
|
|
|
|
|
false, errp) < 0) {
|
2019-09-30 02:24:43 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spapr_xive_hcall_init(spapr);
|
|
|
|
|
}
|
2019-01-02 05:57:40 +00:00
|
|
|
|
2019-09-26 06:09:46 +00:00
|
|
|
spapr->qirqs = qemu_allocate_irqs(spapr_set_irq, spapr,
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE);
|
2018-12-05 23:22:27 +00:00
|
|
|
}
|
2018-07-30 14:11:33 +00:00
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
int spapr_irq_claim(SpaprMachineState *spapr, int irq, bool lsi, Error **errp)
|
2018-07-30 14:11:33 +00:00
|
|
|
{
|
2019-09-26 04:31:13 +00:00
|
|
|
SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
|
|
|
|
|
int i;
|
|
|
|
|
int rc;
|
|
|
|
|
|
2019-09-25 03:49:59 +00:00
|
|
|
assert(irq >= SPAPR_XIRQ_BASE);
|
|
|
|
|
assert(irq < (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
|
|
|
|
|
|
2019-09-26 04:31:13 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(intcs); i++) {
|
|
|
|
|
SpaprInterruptController *intc = intcs[i];
|
|
|
|
|
if (intc) {
|
|
|
|
|
SpaprInterruptControllerClass *sicc = SPAPR_INTC_GET_CLASS(intc);
|
|
|
|
|
rc = sicc->claim_irq(intc, irq, lsi, errp);
|
|
|
|
|
if (rc < 0) {
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
2018-07-30 14:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
void spapr_irq_free(SpaprMachineState *spapr, int irq, int num)
|
2018-07-30 14:11:33 +00:00
|
|
|
{
|
2019-09-26 04:31:13 +00:00
|
|
|
SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
|
|
|
|
|
int i, j;
|
2019-09-24 14:12:21 +00:00
|
|
|
|
2019-09-25 03:49:59 +00:00
|
|
|
assert(irq >= SPAPR_XIRQ_BASE);
|
|
|
|
|
assert((irq + num) <= (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
|
|
|
|
|
|
2019-09-24 14:12:21 +00:00
|
|
|
for (i = irq; i < (irq + num); i++) {
|
2019-09-26 04:31:13 +00:00
|
|
|
for (j = 0; j < ARRAY_SIZE(intcs); j++) {
|
|
|
|
|
SpaprInterruptController *intc = intcs[j];
|
|
|
|
|
|
|
|
|
|
if (intc) {
|
|
|
|
|
SpaprInterruptControllerClass *sicc
|
|
|
|
|
= SPAPR_INTC_GET_CLASS(intc);
|
|
|
|
|
sicc->free_irq(intc, i);
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-09-24 14:12:21 +00:00
|
|
|
}
|
2018-07-30 14:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
|
2018-07-30 14:11:33 +00:00
|
|
|
{
|
2019-09-23 06:18:28 +00:00
|
|
|
/*
|
|
|
|
|
* This interface is basically for VIO and PHB devices to find the
|
|
|
|
|
* right qemu_irq to manipulate, so we only allow access to the
|
|
|
|
|
* external irqs for now. Currently anything which needs to
|
|
|
|
|
* access the IPIs most naturally gets there via the guest side
|
|
|
|
|
* interfaces, we can change this if we need to in future.
|
|
|
|
|
*/
|
|
|
|
|
assert(irq >= SPAPR_XIRQ_BASE);
|
|
|
|
|
assert(irq < (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
|
|
|
|
|
|
|
|
|
|
if (spapr->ics) {
|
|
|
|
|
assert(ics_valid_irq(spapr->ics, irq));
|
|
|
|
|
}
|
|
|
|
|
if (spapr->xive) {
|
|
|
|
|
assert(irq < spapr->xive->nr_irqs);
|
|
|
|
|
assert(xive_eas_is_valid(&spapr->xive->eat[irq]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return spapr->qirqs[irq];
|
2018-07-30 14:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
int spapr_irq_post_load(SpaprMachineState *spapr, int version_id)
|
2018-12-11 22:38:16 +00:00
|
|
|
{
|
2019-09-26 05:41:39 +00:00
|
|
|
spapr_irq_update_active_intc(spapr);
|
2018-12-17 22:34:43 +00:00
|
|
|
return spapr->irq->post_load(spapr, version_id);
|
2018-12-11 22:38:16 +00:00
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
void spapr_irq_reset(SpaprMachineState *spapr, Error **errp)
|
2018-12-11 22:38:17 +00:00
|
|
|
{
|
2019-07-26 14:44:49 +00:00
|
|
|
assert(!spapr->irq_map || bitmap_empty(spapr->irq_map, spapr->irq_map_nr));
|
|
|
|
|
|
2019-09-26 05:41:39 +00:00
|
|
|
spapr_irq_update_active_intc(spapr);
|
|
|
|
|
|
2018-12-17 22:34:43 +00:00
|
|
|
if (spapr->irq->reset) {
|
|
|
|
|
spapr->irq->reset(spapr, errp);
|
2018-12-11 22:38:17 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
int spapr_irq_get_phandle(SpaprMachineState *spapr, void *fdt, Error **errp)
|
2019-02-19 17:18:13 +00:00
|
|
|
{
|
2019-09-23 05:19:28 +00:00
|
|
|
const char *nodename = "interrupt-controller";
|
2019-02-19 17:18:13 +00:00
|
|
|
int offset, phandle;
|
|
|
|
|
|
|
|
|
|
offset = fdt_subnode_offset(fdt, 0, nodename);
|
|
|
|
|
if (offset < 0) {
|
2019-09-23 05:19:28 +00:00
|
|
|
error_setg(errp, "Can't find node \"%s\": %s",
|
|
|
|
|
nodename, fdt_strerror(offset));
|
2019-02-19 17:18:13 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
phandle = fdt_get_phandle(fdt, offset);
|
|
|
|
|
if (!phandle) {
|
|
|
|
|
error_setg(errp, "Can't get phandle of node \"%s\"", nodename);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return phandle;
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-26 05:41:39 +00:00
|
|
|
static void set_active_intc(SpaprMachineState *spapr,
|
|
|
|
|
SpaprInterruptController *new_intc)
|
|
|
|
|
{
|
|
|
|
|
SpaprInterruptControllerClass *sicc;
|
|
|
|
|
|
|
|
|
|
assert(new_intc);
|
|
|
|
|
|
|
|
|
|
if (new_intc == spapr->active_intc) {
|
|
|
|
|
/* Nothing to do */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (spapr->active_intc) {
|
|
|
|
|
sicc = SPAPR_INTC_GET_CLASS(spapr->active_intc);
|
|
|
|
|
if (sicc->deactivate) {
|
|
|
|
|
sicc->deactivate(spapr->active_intc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sicc = SPAPR_INTC_GET_CLASS(new_intc);
|
|
|
|
|
if (sicc->activate) {
|
|
|
|
|
sicc->activate(new_intc, &error_fatal);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spapr->active_intc = new_intc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void spapr_irq_update_active_intc(SpaprMachineState *spapr)
|
|
|
|
|
{
|
|
|
|
|
SpaprInterruptController *new_intc;
|
|
|
|
|
|
|
|
|
|
if (!spapr->ics) {
|
|
|
|
|
/*
|
|
|
|
|
* XXX before we run CAS, ov5_cas is initialized empty, which
|
|
|
|
|
* indicates XICS, even if we have ic-mode=xive. TODO: clean
|
|
|
|
|
* up the CAS path so that we have a clearer way of handling
|
|
|
|
|
* this.
|
|
|
|
|
*/
|
|
|
|
|
new_intc = SPAPR_INTC(spapr->xive);
|
|
|
|
|
} else if (spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT)) {
|
|
|
|
|
new_intc = SPAPR_INTC(spapr->xive);
|
|
|
|
|
} else {
|
|
|
|
|
new_intc = SPAPR_INTC(spapr->ics);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_active_intc(spapr, new_intc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-30 14:11:33 +00:00
|
|
|
/*
|
|
|
|
|
* XICS legacy routines - to deprecate one day
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int ics_find_free_block(ICSState *ics, int num, int alignnum)
|
|
|
|
|
{
|
|
|
|
|
int first, i;
|
|
|
|
|
|
|
|
|
|
for (first = 0; first < ics->nr_irqs; first += alignnum) {
|
|
|
|
|
if (num > (ics->nr_irqs - first)) {
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
for (i = first; i < first + num; ++i) {
|
2019-09-11 13:39:36 +00:00
|
|
|
if (!ics_irq_free(ics, i)) {
|
2018-07-30 14:11:33 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (i == (first + num)) {
|
|
|
|
|
return first;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
int spapr_irq_find(SpaprMachineState *spapr, int num, bool align, Error **errp)
|
2018-07-30 14:11:33 +00:00
|
|
|
{
|
|
|
|
|
ICSState *ics = spapr->ics;
|
|
|
|
|
int first = -1;
|
|
|
|
|
|
|
|
|
|
assert(ics);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MSIMesage::data is used for storing VIRQ so
|
|
|
|
|
* it has to be aligned to num to support multiple
|
|
|
|
|
* MSI vectors. MSI-X is not affected by this.
|
|
|
|
|
* The hint is used for the first IRQ, the rest should
|
|
|
|
|
* be allocated continuously.
|
|
|
|
|
*/
|
|
|
|
|
if (align) {
|
|
|
|
|
assert((num == 1) || (num == 2) || (num == 4) ||
|
|
|
|
|
(num == 8) || (num == 16) || (num == 32));
|
|
|
|
|
first = ics_find_free_block(ics, num, num);
|
|
|
|
|
} else {
|
|
|
|
|
first = ics_find_free_block(ics, num, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (first < 0) {
|
|
|
|
|
error_setg(errp, "can't find a free %d-IRQ block", num);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return first + ics->offset;
|
|
|
|
|
}
|
2018-09-11 05:55:03 +00:00
|
|
|
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
#define SPAPR_IRQ_XICS_LEGACY_NR_XIRQS 0x400
|
2018-09-11 05:55:03 +00:00
|
|
|
|
spapr: Use CamelCase properly
The qemu coding standard is to use CamelCase for type and structure names,
and the pseries code follows that... sort of. There are quite a lot of
places where we bend the rules in order to preserve the capitalization of
internal acronyms like "PHB", "TCE", "DIMM" and most commonly "sPAPR".
That was a bad idea - it frequently leads to names ending up with hard to
read clusters of capital letters, and means they don't catch the eye as
type identifiers, which is kind of the point of the CamelCase convention in
the first place.
In short, keeping type identifiers look like CamelCase is more important
than preserving standard capitalization of internal "words". So, this
patch renames a heap of spapr internal type names to a more standard
CamelCase.
In addition to case changes, we also make some other identifier renames:
VIOsPAPR* -> SpaprVio*
The reverse word ordering was only ever used to mitigate the capital
cluster, so revert to the natural ordering.
VIOsPAPRVTYDevice -> SpaprVioVty
VIOsPAPRVLANDevice -> SpaprVioVlan
Brevity, since the "Device" didn't add useful information
sPAPRDRConnector -> SpaprDrc
sPAPRDRConnectorClass -> SpaprDrcClass
Brevity, and makes it clearer this is the same thing as a "DRC"
mentioned in many other places in the code
This is 100% a mechanical search-and-replace patch. It will, however,
conflict with essentially any and all outstanding patches touching the
spapr code.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2019-03-06 04:35:37 +00:00
|
|
|
SpaprIrq spapr_irq_xics_legacy = {
|
spapr: Clarify and fix handling of nr_irqs
Both the XICS and XIVE interrupt backends have a "nr-irqs" property, but
it means slightly different things. For XICS (or, strictly, the ICS) it
indicates the number of "real" external IRQs. Those start at XICS_IRQ_BASE
(0x1000) and don't include the special IPI vector. For XIVE, however, it
includes the whole IRQ space, including XIVE's many IPI vectors.
The spapr code currently doesn't handle this sensibly, with the
nr_irqs value in SpaprIrq having different meanings depending on the
backend. We fix this by renaming nr_irqs to nr_xirqs and making it
always indicate just the number of external irqs, adjusting the value
we pass to XIVE accordingly. We also move to using common constants
in most of the irq configurations, to make it clearer that the IRQ
space looks the same to the guest (and emulated devices), even if the
backend is different.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
2019-09-24 00:53:50 +00:00
|
|
|
.nr_xirqs = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
|
|
|
|
|
.nr_msis = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
|
2019-09-25 05:12:07 +00:00
|
|
|
.xics = true,
|
|
|
|
|
.xive = false,
|
2018-09-11 05:55:03 +00:00
|
|
|
|
2018-12-11 22:38:16 +00:00
|
|
|
.post_load = spapr_irq_post_load_xics,
|
2019-05-13 08:42:45 +00:00
|
|
|
.reset = spapr_irq_reset_xics,
|
|
|
|
|
.init_kvm = spapr_irq_init_kvm_xics,
|
2018-09-11 05:55:03 +00:00
|
|
|
};
|
2019-09-24 06:25:08 +00:00
|
|
|
|
|
|
|
|
static void spapr_irq_register_types(void)
|
|
|
|
|
{
|
|
|
|
|
type_register_static(&spapr_intc_info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type_init(spapr_irq_register_types)
|