2018-07-30 16:11:32 +02: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"
|
|
|
|
#include "hw/ppc/spapr.h"
|
2019-01-17 08:53:26 +01:00
|
|
|
#include "hw/ppc/spapr_cpu_core.h"
|
2018-12-11 23:38:12 +01:00
|
|
|
#include "hw/ppc/spapr_xive.h"
|
2018-07-30 16:11:32 +02:00
|
|
|
#include "hw/ppc/xics.h"
|
2019-01-10 09:18:47 +01:00
|
|
|
#include "hw/ppc/xics_spapr.h"
|
2019-03-28 11:00:44 +01:00
|
|
|
#include "cpu-models.h"
|
2018-07-30 16:11:33 +02:00
|
|
|
#include "sysemu/kvm.h"
|
|
|
|
|
|
|
|
#include "trace.h"
|
2018-07-30 16:11:32 +02: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 05:35:37 +01:00
|
|
|
void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis)
|
2018-07-30 16:11:32 +02: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 05:35:37 +01:00
|
|
|
int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
|
2018-07-30 16:11:32 +02: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 05:35:37 +01:00
|
|
|
void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num)
|
2018-07-30 16:11:32 +02:00
|
|
|
{
|
|
|
|
bitmap_clear(spapr->irq_map, irq - SPAPR_IRQ_MSI, num);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
void spapr_irq_msi_reset(SpaprMachineState *spapr)
|
2018-07-30 16:11:32 +02:00
|
|
|
{
|
|
|
|
bitmap_clear(spapr->irq_map, 0, spapr->irq_map_nr);
|
|
|
|
}
|
2018-07-30 16:11:33 +02:00
|
|
|
|
2019-05-13 10:42:42 +02:00
|
|
|
static void spapr_irq_init_device(SpaprMachineState *spapr,
|
|
|
|
SpaprIrq *irq, Error **errp)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
|
|
|
MachineState *machine = MACHINE(spapr);
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2019-05-13 10:42:42 +02: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 16:11:33 +02:00
|
|
|
error_prepend(&local_err,
|
|
|
|
"kernel_irqchip requested but unavailable: ");
|
2019-03-21 15:49:11 +01:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
2018-07-30 16:11:33 +02:00
|
|
|
}
|
2019-05-13 10:42:42 +02: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: ");
|
|
|
|
warn_report_err(local_err);
|
2018-07-30 16:11:33 +02:00
|
|
|
}
|
|
|
|
|
2019-05-13 10:42:42 +02:00
|
|
|
irq->init_emu(spapr, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XICS IRQ backend.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void spapr_irq_init_xics(SpaprMachineState *spapr, int nr_irqs,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Object *obj;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2019-03-21 15:49:11 +01:00
|
|
|
obj = object_new(TYPE_ICS_SIMPLE);
|
|
|
|
object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort);
|
|
|
|
object_property_add_const_link(obj, ICS_PROP_XICS, OBJECT(spapr),
|
|
|
|
&error_fatal);
|
|
|
|
object_property_set_int(obj, nr_irqs, "nr-irqs", &error_fatal);
|
|
|
|
object_property_set_bool(obj, true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2019-02-15 12:40:35 +01:00
|
|
|
|
2019-03-21 15:49:11 +01:00
|
|
|
spapr->ics = ICS_BASE(obj);
|
2019-06-13 18:44:59 +02:00
|
|
|
|
|
|
|
xics_spapr_init(spapr);
|
2018-07-30 16:11:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#define ICS_IRQ_FREE(ics, srcno) \
|
|
|
|
(!((ics)->irqs[(srcno)].flags & (XICS_FLAGS_IRQ_MASK)))
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static int spapr_irq_claim_xics(SpaprMachineState *spapr, int irq, bool lsi,
|
2018-07-30 16:11:33 +02:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
ICSState *ics = spapr->ics;
|
|
|
|
|
|
|
|
assert(ics);
|
|
|
|
|
|
|
|
if (!ics_valid_irq(ics, irq)) {
|
|
|
|
error_setg(errp, "IRQ %d is invalid", irq);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ICS_IRQ_FREE(ics, irq - ics->offset)) {
|
|
|
|
error_setg(errp, "IRQ %d is not free", irq);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ics_set_irq_type(ics, irq - ics->offset, lsi);
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_free_xics(SpaprMachineState *spapr, int irq, int num)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
|
|
|
ICSState *ics = spapr->ics;
|
|
|
|
uint32_t srcno = irq - ics->offset;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (ics_valid_irq(ics, irq)) {
|
|
|
|
trace_spapr_irq_free(0, irq, num);
|
|
|
|
for (i = srcno; i < srcno + num; ++i) {
|
|
|
|
if (ICS_IRQ_FREE(ics, i)) {
|
|
|
|
trace_spapr_irq_free_warn(0, i);
|
|
|
|
}
|
|
|
|
memset(&ics->irqs[i], 0, sizeof(ICSIRQState));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static qemu_irq spapr_qirq_xics(SpaprMachineState *spapr, int irq)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
|
|
|
ICSState *ics = spapr->ics;
|
|
|
|
uint32_t srcno = irq - ics->offset;
|
|
|
|
|
|
|
|
if (ics_valid_irq(ics, irq)) {
|
2019-01-02 06:57:40 +01:00
|
|
|
return spapr->qirqs[srcno];
|
2018-07-30 16:11:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_print_info_xics(SpaprMachineState *spapr, Monitor *mon)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
|
|
|
CPUState *cs;
|
|
|
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
|
|
|
2019-01-17 08:53:26 +01:00
|
|
|
icp_pic_print_info(spapr_cpu_state(cpu)->icp, mon);
|
2018-07-30 16:11:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ics_pic_print_info(spapr->ics, mon);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_cpu_intc_create_xics(SpaprMachineState *spapr,
|
2019-01-02 06:57:34 +01:00
|
|
|
PowerPCCPU *cpu, Error **errp)
|
2018-12-11 23:38:15 +01:00
|
|
|
{
|
2019-01-02 06:57:34 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
Object *obj;
|
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 05:35:37 +01:00
|
|
|
SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
|
2019-01-02 06:57:34 +01:00
|
|
|
|
2019-02-15 12:40:06 +01:00
|
|
|
obj = icp_create(OBJECT(cpu), TYPE_ICP, XICS_FABRIC(spapr),
|
2019-01-02 06:57:34 +01:00
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-17 08:53:26 +01:00
|
|
|
spapr_cpu->icp = ICP(obj);
|
2018-12-11 23:38:15 +01: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 05:35:37 +01:00
|
|
|
static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
|
2018-12-11 23:38:16 +01:00
|
|
|
{
|
2019-02-15 12:40:41 +01:00
|
|
|
if (!kvm_irqchip_in_kernel()) {
|
2018-12-11 23:38:16 +01:00
|
|
|
CPUState *cs;
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
2019-01-17 08:53:26 +01:00
|
|
|
icp_resend(spapr_cpu_state(cpu)->icp);
|
2018-12-11 23:38:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-02 06:57:40 +01:00
|
|
|
static void spapr_irq_set_irq_xics(void *opaque, int srcno, int val)
|
|
|
|
{
|
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 05:35:37 +01:00
|
|
|
SpaprMachineState *spapr = opaque;
|
2019-01-02 06:57:40 +01:00
|
|
|
|
2019-02-15 12:40:30 +01:00
|
|
|
ics_simple_set_irq(spapr->ics, srcno, val);
|
2019-01-02 06:57:40 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
2019-05-13 10:42:45 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
spapr_irq_init_device(spapr, &spapr_irq_xics, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2019-01-02 06:57:42 +01: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 05:35:37 +01:00
|
|
|
static const char *spapr_irq_get_nodename_xics(SpaprMachineState *spapr)
|
2019-02-19 18:18:08 +01:00
|
|
|
{
|
|
|
|
return XICS_NODENAME;
|
|
|
|
}
|
|
|
|
|
2019-05-13 10:42:42 +02:00
|
|
|
static void spapr_irq_init_emu_xics(SpaprMachineState *spapr, Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_irq_init_kvm_xics(SpaprMachineState *spapr, Error **errp)
|
|
|
|
{
|
|
|
|
if (kvm_enabled()) {
|
|
|
|
xics_kvm_init(spapr, errp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-11 07:55:03 +02:00
|
|
|
#define SPAPR_IRQ_XICS_NR_IRQS 0x1000
|
2018-09-11 07:55:02 +02:00
|
|
|
#define SPAPR_IRQ_XICS_NR_MSIS \
|
|
|
|
(XICS_IRQ_BASE + SPAPR_IRQ_XICS_NR_IRQS - 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 05:35:37 +01:00
|
|
|
SpaprIrq spapr_irq_xics = {
|
2018-09-11 07:55:02 +02:00
|
|
|
.nr_irqs = SPAPR_IRQ_XICS_NR_IRQS,
|
|
|
|
.nr_msis = SPAPR_IRQ_XICS_NR_MSIS,
|
2018-12-17 23:34:42 +01:00
|
|
|
.ov5 = SPAPR_OV5_XIVE_LEGACY,
|
2018-07-30 16:11:33 +02:00
|
|
|
|
|
|
|
.init = spapr_irq_init_xics,
|
|
|
|
.claim = spapr_irq_claim_xics,
|
|
|
|
.free = spapr_irq_free_xics,
|
|
|
|
.qirq = spapr_qirq_xics,
|
|
|
|
.print_info = spapr_irq_print_info_xics,
|
2018-12-11 23:38:14 +01:00
|
|
|
.dt_populate = spapr_dt_xics,
|
2018-12-11 23:38:15 +01:00
|
|
|
.cpu_intc_create = spapr_irq_cpu_intc_create_xics,
|
2018-12-11 23:38:16 +01:00
|
|
|
.post_load = spapr_irq_post_load_xics,
|
2019-01-02 06:57:42 +01:00
|
|
|
.reset = spapr_irq_reset_xics,
|
2019-01-02 06:57:40 +01:00
|
|
|
.set_irq = spapr_irq_set_irq_xics,
|
2019-02-19 18:18:08 +01:00
|
|
|
.get_nodename = spapr_irq_get_nodename_xics,
|
2019-05-13 10:42:42 +02:00
|
|
|
.init_emu = spapr_irq_init_emu_xics,
|
|
|
|
.init_kvm = spapr_irq_init_kvm_xics,
|
2018-07-30 16:11:33 +02:00
|
|
|
};
|
|
|
|
|
2018-12-11 23:38:12 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_init_xive(SpaprMachineState *spapr, int nr_irqs,
|
2019-02-13 22:07:55 +01:00
|
|
|
Error **errp)
|
2018-12-11 23:38:12 +01:00
|
|
|
{
|
|
|
|
uint32_t nr_servers = spapr_max_server_number(spapr);
|
|
|
|
DeviceState *dev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dev = qdev_create(NULL, TYPE_SPAPR_XIVE);
|
2019-02-13 22:07:55 +01:00
|
|
|
qdev_prop_set_uint32(dev, "nr-irqs", nr_irqs);
|
2018-12-11 23:38:12 +01:00
|
|
|
/*
|
|
|
|
* 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) {
|
|
|
|
spapr_xive_irq_claim(spapr->xive, SPAPR_IRQ_IPI + i, false);
|
|
|
|
}
|
2018-12-11 23:38:13 +01:00
|
|
|
|
|
|
|
spapr_xive_hcall_init(spapr);
|
2018-12-11 23:38:12 +01: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 05:35:37 +01:00
|
|
|
static int spapr_irq_claim_xive(SpaprMachineState *spapr, int irq, bool lsi,
|
2018-12-11 23:38:12 +01:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
if (!spapr_xive_irq_claim(spapr->xive, irq, lsi)) {
|
|
|
|
error_setg(errp, "IRQ %d is invalid", irq);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_free_xive(SpaprMachineState *spapr, int irq, int num)
|
2018-12-11 23:38:12 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = irq; i < irq + num; ++i) {
|
|
|
|
spapr_xive_irq_free(spapr->xive, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static qemu_irq spapr_qirq_xive(SpaprMachineState *spapr, int irq)
|
2018-12-11 23:38:12 +01: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 05:35:37 +01:00
|
|
|
SpaprXive *xive = spapr->xive;
|
2019-01-02 06:57:37 +01:00
|
|
|
|
|
|
|
if (irq >= xive->nr_irqs) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The sPAPR machine/device should have claimed the IRQ before */
|
|
|
|
assert(xive_eas_is_valid(&xive->eat[irq]));
|
|
|
|
|
2019-01-02 06:57:40 +01:00
|
|
|
return spapr->qirqs[irq];
|
2018-12-11 23:38:12 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_print_info_xive(SpaprMachineState *spapr,
|
2018-12-11 23:38:12 +01:00
|
|
|
Monitor *mon)
|
|
|
|
{
|
|
|
|
CPUState *cs;
|
|
|
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
|
|
|
2019-01-17 08:53:26 +01:00
|
|
|
xive_tctx_pic_print_info(spapr_cpu_state(cpu)->tctx, mon);
|
2018-12-11 23:38:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
spapr_xive_pic_print_info(spapr->xive, mon);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_cpu_intc_create_xive(SpaprMachineState *spapr,
|
2019-01-02 06:57:34 +01:00
|
|
|
PowerPCCPU *cpu, Error **errp)
|
2018-12-11 23:38:15 +01:00
|
|
|
{
|
2019-01-02 06:57:34 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
Object *obj;
|
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 05:35:37 +01:00
|
|
|
SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
|
2019-01-02 06:57:34 +01:00
|
|
|
|
|
|
|
obj = xive_tctx_create(OBJECT(cpu), XIVE_ROUTER(spapr->xive), &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-17 08:53:26 +01:00
|
|
|
spapr_cpu->tctx = XIVE_TCTX(obj);
|
2018-12-11 23:38:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* (TCG) Early setting the OS CAM line for hotplugged CPUs as they
|
2019-01-02 06:57:34 +01:00
|
|
|
* don't beneficiate from the reset of the XIVE IRQ backend
|
2018-12-11 23:38:17 +01:00
|
|
|
*/
|
2019-01-17 08:53:26 +01:00
|
|
|
spapr_xive_set_tctx_os_cam(spapr_cpu->tctx);
|
2018-12-11 23:38:15 +01: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 05:35:37 +01:00
|
|
|
static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
|
2018-12-11 23:38:16 +01:00
|
|
|
{
|
2019-05-13 10:42:37 +02:00
|
|
|
return spapr_xive_post_load(spapr->xive, version_id);
|
2018-12-11 23:38:16 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
|
2018-12-11 23:38:17 +01:00
|
|
|
{
|
|
|
|
CPUState *cs;
|
2019-05-13 10:42:45 +02:00
|
|
|
Error *local_err = NULL;
|
2018-12-11 23:38:17 +01:00
|
|
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
|
|
|
|
|
|
/* (TCG) Set the OS CAM line of the thread interrupt context. */
|
2019-01-17 08:53:26 +01:00
|
|
|
spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
|
2018-12-11 23:38:17 +01:00
|
|
|
}
|
2019-01-02 06:57:43 +01:00
|
|
|
|
2019-05-13 10:42:45 +02:00
|
|
|
spapr_irq_init_device(spapr, &spapr_irq_xive, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-02 06:57:43 +01:00
|
|
|
/* Activate the XIVE MMIOs */
|
|
|
|
spapr_xive_mmio_set_enabled(spapr->xive, true);
|
2018-12-11 23:38:17 +01:00
|
|
|
}
|
|
|
|
|
2019-01-02 06:57:40 +01:00
|
|
|
static void spapr_irq_set_irq_xive(void *opaque, int srcno, int val)
|
|
|
|
{
|
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 05:35:37 +01:00
|
|
|
SpaprMachineState *spapr = opaque;
|
2019-01-02 06:57:40 +01:00
|
|
|
|
2019-05-13 10:42:33 +02:00
|
|
|
if (kvm_irqchip_in_kernel()) {
|
|
|
|
kvmppc_xive_source_set_irq(&spapr->xive->source, srcno, val);
|
|
|
|
} else {
|
|
|
|
xive_source_set_irq(&spapr->xive->source, srcno, val);
|
|
|
|
}
|
2019-01-02 06:57:40 +01: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 05:35:37 +01:00
|
|
|
static const char *spapr_irq_get_nodename_xive(SpaprMachineState *spapr)
|
2019-02-19 18:18:08 +01:00
|
|
|
{
|
|
|
|
return spapr->xive->nodename;
|
|
|
|
}
|
|
|
|
|
2019-05-13 10:42:42 +02:00
|
|
|
static void spapr_irq_init_emu_xive(SpaprMachineState *spapr, Error **errp)
|
|
|
|
{
|
|
|
|
spapr_xive_init(spapr->xive, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_irq_init_kvm_xive(SpaprMachineState *spapr, Error **errp)
|
|
|
|
{
|
|
|
|
if (kvm_enabled()) {
|
|
|
|
kvmppc_xive_connect(spapr->xive, errp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-11 23:38:12 +01:00
|
|
|
/*
|
|
|
|
* XIVE uses the full IRQ number space. Set it to 8K to be compatible
|
|
|
|
* with XICS.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define SPAPR_IRQ_XIVE_NR_IRQS 0x2000
|
|
|
|
#define SPAPR_IRQ_XIVE_NR_MSIS (SPAPR_IRQ_XIVE_NR_IRQS - 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 05:35:37 +01:00
|
|
|
SpaprIrq spapr_irq_xive = {
|
2018-12-11 23:38:12 +01:00
|
|
|
.nr_irqs = SPAPR_IRQ_XIVE_NR_IRQS,
|
|
|
|
.nr_msis = SPAPR_IRQ_XIVE_NR_MSIS,
|
2018-12-17 23:34:42 +01:00
|
|
|
.ov5 = SPAPR_OV5_XIVE_EXPLOIT,
|
2018-12-11 23:38:12 +01:00
|
|
|
|
|
|
|
.init = spapr_irq_init_xive,
|
|
|
|
.claim = spapr_irq_claim_xive,
|
|
|
|
.free = spapr_irq_free_xive,
|
|
|
|
.qirq = spapr_qirq_xive,
|
|
|
|
.print_info = spapr_irq_print_info_xive,
|
2018-12-11 23:38:14 +01:00
|
|
|
.dt_populate = spapr_dt_xive,
|
2018-12-11 23:38:15 +01:00
|
|
|
.cpu_intc_create = spapr_irq_cpu_intc_create_xive,
|
2018-12-11 23:38:16 +01:00
|
|
|
.post_load = spapr_irq_post_load_xive,
|
2018-12-11 23:38:17 +01:00
|
|
|
.reset = spapr_irq_reset_xive,
|
2019-01-02 06:57:40 +01:00
|
|
|
.set_irq = spapr_irq_set_irq_xive,
|
2019-02-19 18:18:08 +01:00
|
|
|
.get_nodename = spapr_irq_get_nodename_xive,
|
2019-05-13 10:42:42 +02:00
|
|
|
.init_emu = spapr_irq_init_emu_xive,
|
|
|
|
.init_kvm = spapr_irq_init_kvm_xive,
|
2018-12-11 23:38:12 +01:00
|
|
|
};
|
|
|
|
|
2019-01-02 06:57:42 +01: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 05:35:37 +01:00
|
|
|
static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
|
2019-01-02 06:57:42 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_init_dual(SpaprMachineState *spapr, int nr_irqs,
|
2019-02-13 22:07:55 +01:00
|
|
|
Error **errp)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2019-02-13 22:07:55 +01:00
|
|
|
spapr_irq_xics.init(spapr, spapr_irq_xics.nr_irqs, &local_err);
|
2019-01-02 06:57:42 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-02-13 22:07:55 +01:00
|
|
|
spapr_irq_xive.init(spapr, spapr_irq_xive.nr_irqs, &local_err);
|
2019-01-02 06:57:42 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static int spapr_irq_claim_dual(SpaprMachineState *spapr, int irq, bool lsi,
|
2019-01-02 06:57:42 +01:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = spapr_irq_xics.claim(spapr, irq, lsi, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = spapr_irq_xive.claim(spapr, irq, lsi, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_free_dual(SpaprMachineState *spapr, int irq, int num)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
|
|
|
spapr_irq_xics.free(spapr, irq, num);
|
|
|
|
spapr_irq_xive.free(spapr, irq, num);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static qemu_irq spapr_qirq_dual(SpaprMachineState *spapr, int irq)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
2019-02-13 22:07:56 +01:00
|
|
|
return spapr_irq_current(spapr)->qirq(spapr, irq);
|
2019-01-02 06:57:42 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_print_info_dual(SpaprMachineState *spapr, Monitor *mon)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
|
|
|
spapr_irq_current(spapr)->print_info(spapr, mon);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static void spapr_irq_dt_populate_dual(SpaprMachineState *spapr,
|
2019-01-02 06:57:42 +01:00
|
|
|
uint32_t nr_servers, void *fdt,
|
|
|
|
uint32_t phandle)
|
|
|
|
{
|
|
|
|
spapr_irq_current(spapr)->dt_populate(spapr, 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 05:35:37 +01:00
|
|
|
static void spapr_irq_cpu_intc_create_dual(SpaprMachineState *spapr,
|
2019-01-02 06:57:42 +01:00
|
|
|
PowerPCCPU *cpu, Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
spapr_irq_xive.cpu_intc_create(spapr, cpu, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spapr_irq_xics.cpu_intc_create(spapr, cpu, errp);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
|
2019-01-02 06:57:42 +01: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 10:42:45 +02:00
|
|
|
if (kvm_irqchip_in_kernel()) {
|
|
|
|
xics_kvm_disconnect(spapr, &error_fatal);
|
|
|
|
}
|
2019-01-02 06:57:42 +01: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 05:35:37 +01:00
|
|
|
static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
|
2019-01-02 06:57:42 +01:00
|
|
|
{
|
2019-05-13 10:42:45 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2019-01-02 06:57:43 +01:00
|
|
|
/*
|
|
|
|
* Deactivate the XIVE MMIOs. The XIVE backend will reenable them
|
|
|
|
* if selected.
|
|
|
|
*/
|
|
|
|
spapr_xive_mmio_set_enabled(spapr->xive, false);
|
|
|
|
|
2019-05-13 10:42:45 +02:00
|
|
|
/* Destroy all KVM devices */
|
|
|
|
if (kvm_irqchip_in_kernel()) {
|
|
|
|
xics_kvm_disconnect(spapr, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
error_prepend(errp, "KVM XICS disconnect failed: ");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
kvmppc_xive_disconnect(spapr->xive, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
error_prepend(errp, "KVM XIVE disconnect failed: ");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-02 06:57:42 +01:00
|
|
|
spapr_irq_current(spapr)->reset(spapr, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_irq_set_irq_dual(void *opaque, int srcno, int val)
|
|
|
|
{
|
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 05:35:37 +01:00
|
|
|
SpaprMachineState *spapr = opaque;
|
2019-01-02 06:57:42 +01:00
|
|
|
|
|
|
|
spapr_irq_current(spapr)->set_irq(spapr, srcno, val);
|
|
|
|
}
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
static const char *spapr_irq_get_nodename_dual(SpaprMachineState *spapr)
|
2019-02-19 18:18:08 +01:00
|
|
|
{
|
|
|
|
return spapr_irq_current(spapr)->get_nodename(spapr);
|
|
|
|
}
|
|
|
|
|
2019-01-02 06:57:42 +01:00
|
|
|
/*
|
|
|
|
* Define values in sync with the XIVE and XICS backend
|
|
|
|
*/
|
|
|
|
#define SPAPR_IRQ_DUAL_NR_IRQS 0x2000
|
|
|
|
#define SPAPR_IRQ_DUAL_NR_MSIS (SPAPR_IRQ_DUAL_NR_IRQS - 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 05:35:37 +01:00
|
|
|
SpaprIrq spapr_irq_dual = {
|
2019-01-02 06:57:42 +01:00
|
|
|
.nr_irqs = SPAPR_IRQ_DUAL_NR_IRQS,
|
|
|
|
.nr_msis = SPAPR_IRQ_DUAL_NR_MSIS,
|
|
|
|
.ov5 = SPAPR_OV5_XIVE_BOTH,
|
|
|
|
|
|
|
|
.init = spapr_irq_init_dual,
|
|
|
|
.claim = spapr_irq_claim_dual,
|
|
|
|
.free = spapr_irq_free_dual,
|
|
|
|
.qirq = spapr_qirq_dual,
|
|
|
|
.print_info = spapr_irq_print_info_dual,
|
|
|
|
.dt_populate = spapr_irq_dt_populate_dual,
|
|
|
|
.cpu_intc_create = spapr_irq_cpu_intc_create_dual,
|
|
|
|
.post_load = spapr_irq_post_load_dual,
|
|
|
|
.reset = spapr_irq_reset_dual,
|
2019-02-19 18:18:08 +01:00
|
|
|
.set_irq = spapr_irq_set_irq_dual,
|
|
|
|
.get_nodename = spapr_irq_get_nodename_dual,
|
2019-05-13 10:42:42 +02:00
|
|
|
.init_emu = NULL, /* should not be used */
|
|
|
|
.init_kvm = NULL, /* should not be used */
|
2019-01-02 06:57:42 +01:00
|
|
|
};
|
|
|
|
|
2019-03-28 11:00:44 +01:00
|
|
|
|
|
|
|
static void spapr_irq_check(SpaprMachineState *spapr, Error **errp)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-30 16:11:33 +02:00
|
|
|
/*
|
|
|
|
* sPAPR IRQ frontend routines for devices
|
|
|
|
*/
|
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 05:35:37 +01:00
|
|
|
void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
|
2018-12-06 00:22:27 +01: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 19:17:47 +01:00
|
|
|
MachineState *machine = MACHINE(spapr);
|
2019-03-28 11:00:44 +01:00
|
|
|
Error *local_err = NULL;
|
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 19:17:47 +01:00
|
|
|
|
|
|
|
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-03-28 11:00:44 +01:00
|
|
|
spapr_irq_check(spapr, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-12-06 00:22:27 +01:00
|
|
|
/* Initialize the MSI IRQ allocator. */
|
|
|
|
if (!SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
|
2018-12-17 23:34:43 +01:00
|
|
|
spapr_irq_msi_init(spapr, spapr->irq->nr_msis);
|
2018-12-06 00:22:27 +01:00
|
|
|
}
|
|
|
|
|
2019-02-13 22:07:55 +01:00
|
|
|
spapr->irq->init(spapr, spapr->irq->nr_irqs, errp);
|
2019-01-02 06:57:40 +01:00
|
|
|
|
|
|
|
spapr->qirqs = qemu_allocate_irqs(spapr->irq->set_irq, spapr,
|
|
|
|
spapr->irq->nr_irqs);
|
2018-12-06 00:22:27 +01:00
|
|
|
}
|
2018-07-30 16:11:33 +02: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 05:35:37 +01:00
|
|
|
int spapr_irq_claim(SpaprMachineState *spapr, int irq, bool lsi, Error **errp)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
2018-12-17 23:34:43 +01:00
|
|
|
return spapr->irq->claim(spapr, irq, lsi, errp);
|
2018-07-30 16:11:33 +02: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 05:35:37 +01:00
|
|
|
void spapr_irq_free(SpaprMachineState *spapr, int irq, int num)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
2018-12-17 23:34:43 +01:00
|
|
|
spapr->irq->free(spapr, irq, num);
|
2018-07-30 16:11:33 +02: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 05:35:37 +01:00
|
|
|
qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
|
2018-07-30 16:11:33 +02:00
|
|
|
{
|
2018-12-17 23:34:43 +01:00
|
|
|
return spapr->irq->qirq(spapr, irq);
|
2018-07-30 16:11:33 +02: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 05:35:37 +01:00
|
|
|
int spapr_irq_post_load(SpaprMachineState *spapr, int version_id)
|
2018-12-11 23:38:16 +01:00
|
|
|
{
|
2018-12-17 23:34:43 +01:00
|
|
|
return spapr->irq->post_load(spapr, version_id);
|
2018-12-11 23:38:16 +01: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 05:35:37 +01:00
|
|
|
void spapr_irq_reset(SpaprMachineState *spapr, Error **errp)
|
2018-12-11 23:38:17 +01:00
|
|
|
{
|
2018-12-17 23:34:43 +01:00
|
|
|
if (spapr->irq->reset) {
|
|
|
|
spapr->irq->reset(spapr, errp);
|
2018-12-11 23:38:17 +01: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 05:35:37 +01:00
|
|
|
int spapr_irq_get_phandle(SpaprMachineState *spapr, void *fdt, Error **errp)
|
2019-02-19 18:18:13 +01:00
|
|
|
{
|
|
|
|
const char *nodename = spapr->irq->get_nodename(spapr);
|
|
|
|
int offset, phandle;
|
|
|
|
|
|
|
|
offset = fdt_subnode_offset(fdt, 0, nodename);
|
|
|
|
if (offset < 0) {
|
|
|
|
error_setg(errp, "Can't find node \"%s\": %s", nodename,
|
|
|
|
fdt_strerror(offset));
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-07-30 16:11:33 +02: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) {
|
|
|
|
if (!ICS_IRQ_FREE(ics, i)) {
|
|
|
|
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 05:35:37 +01:00
|
|
|
int spapr_irq_find(SpaprMachineState *spapr, int num, bool align, Error **errp)
|
2018-07-30 16:11:33 +02: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 07:55:03 +02:00
|
|
|
|
|
|
|
#define SPAPR_IRQ_XICS_LEGACY_NR_IRQS 0x400
|
|
|
|
|
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 05:35:37 +01:00
|
|
|
SpaprIrq spapr_irq_xics_legacy = {
|
2018-09-11 07:55:03 +02:00
|
|
|
.nr_irqs = SPAPR_IRQ_XICS_LEGACY_NR_IRQS,
|
|
|
|
.nr_msis = SPAPR_IRQ_XICS_LEGACY_NR_IRQS,
|
2018-12-17 23:34:42 +01:00
|
|
|
.ov5 = SPAPR_OV5_XIVE_LEGACY,
|
2018-09-11 07:55:03 +02:00
|
|
|
|
|
|
|
.init = spapr_irq_init_xics,
|
|
|
|
.claim = spapr_irq_claim_xics,
|
|
|
|
.free = spapr_irq_free_xics,
|
|
|
|
.qirq = spapr_qirq_xics,
|
|
|
|
.print_info = spapr_irq_print_info_xics,
|
2018-12-11 23:38:14 +01:00
|
|
|
.dt_populate = spapr_dt_xics,
|
2018-12-11 23:38:15 +01:00
|
|
|
.cpu_intc_create = spapr_irq_cpu_intc_create_xics,
|
2018-12-11 23:38:16 +01:00
|
|
|
.post_load = spapr_irq_post_load_xics,
|
2019-05-13 10:42:45 +02:00
|
|
|
.reset = spapr_irq_reset_xics,
|
2019-01-02 06:57:40 +01:00
|
|
|
.set_irq = spapr_irq_set_irq_xics,
|
2019-02-19 18:18:08 +01:00
|
|
|
.get_nodename = spapr_irq_get_nodename_xics,
|
2019-05-13 10:42:45 +02:00
|
|
|
.init_emu = spapr_irq_init_emu_xics,
|
|
|
|
.init_kvm = spapr_irq_init_kvm_xics,
|
2018-09-11 07:55:03 +02:00
|
|
|
};
|