2011-10-30 21:16:46 +04:00
|
|
|
/*
|
|
|
|
* QEMU sPAPR PCI host originated from Uninorth PCI host
|
|
|
|
*
|
|
|
|
* Copyright (c) 2011 Alexey Kardashevskiy, IBM Corporation.
|
|
|
|
* Copyright (C) 2011 David Gibson, IBM Corporation.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2016-01-26 21:16:58 +03:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2016-01-19 23:51:44 +03:00
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "cpu.h"
|
2013-02-04 18:40:22 +04:00
|
|
|
#include "hw/hw.h"
|
2015-07-02 09:23:21 +03:00
|
|
|
#include "hw/sysbus.h"
|
2013-02-04 18:40:22 +04:00
|
|
|
#include "hw/pci/pci.h"
|
|
|
|
#include "hw/pci/msi.h"
|
|
|
|
#include "hw/pci/msix.h"
|
|
|
|
#include "hw/pci/pci_host.h"
|
2013-02-05 20:06:20 +04:00
|
|
|
#include "hw/ppc/spapr.h"
|
|
|
|
#include "hw/pci-host/spapr.h"
|
2012-12-17 21:19:49 +04:00
|
|
|
#include "exec/address-spaces.h"
|
2016-07-04 06:33:07 +03:00
|
|
|
#include "exec/ram_addr.h"
|
2011-10-30 21:16:46 +04:00
|
|
|
#include <libfdt.h>
|
2012-08-07 20:10:36 +04:00
|
|
|
#include "trace.h"
|
2013-11-21 08:08:58 +04:00
|
|
|
#include "qemu/error-report.h"
|
2015-05-07 08:33:55 +03:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2015-07-02 09:23:21 +03:00
|
|
|
#include "hw/pci/pci_bridge.h"
|
2012-12-12 17:00:45 +04:00
|
|
|
#include "hw/pci/pci_bus.h"
|
2015-05-07 08:33:53 +03:00
|
|
|
#include "hw/ppc/spapr_drc.h"
|
2015-05-07 08:33:55 +03:00
|
|
|
#include "sysemu/device_tree.h"
|
2014-09-17 14:21:29 +04:00
|
|
|
#include "sysemu/kvm.h"
|
2016-07-04 06:33:07 +03:00
|
|
|
#include "sysemu/hostmem.h"
|
2016-07-27 11:03:38 +03:00
|
|
|
#include "sysemu/numa.h"
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2016-02-29 09:19:42 +03:00
|
|
|
#include "hw/vfio/vfio.h"
|
|
|
|
|
2012-08-07 20:10:37 +04:00
|
|
|
/* Copied from the kernel arch/powerpc/platforms/pseries/msi.c */
|
|
|
|
#define RTAS_QUERY_FN 0
|
|
|
|
#define RTAS_CHANGE_FN 1
|
|
|
|
#define RTAS_RESET_FN 2
|
|
|
|
#define RTAS_CHANGE_MSI_FN 3
|
|
|
|
#define RTAS_CHANGE_MSIX_FN 4
|
|
|
|
|
|
|
|
/* Interrupt types to return on RTAS_CHANGE_* */
|
|
|
|
#define RTAS_TYPE_MSI 1
|
|
|
|
#define RTAS_TYPE_MSIX 2
|
|
|
|
|
2015-07-02 09:23:10 +03:00
|
|
|
#define FDT_NAME_MAX 128
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
#define _FDT(exp) \
|
|
|
|
do { \
|
|
|
|
int ret = (exp); \
|
|
|
|
if (ret < 0) { \
|
|
|
|
return ret; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRPHBState *spapr_pci_find_phb(sPAPRMachineState *spapr, uint64_t buid)
|
2011-10-30 21:16:46 +04:00
|
|
|
{
|
2012-08-20 21:08:05 +04:00
|
|
|
sPAPRPHBState *sphb;
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
QLIST_FOREACH(sphb, &spapr->phbs, list) {
|
|
|
|
if (sphb->buid != buid) {
|
2011-10-30 21:16:46 +04:00
|
|
|
continue;
|
|
|
|
}
|
2012-08-20 21:08:05 +04:00
|
|
|
return sphb;
|
2012-08-07 20:10:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
PCIDevice *spapr_pci_find_dev(sPAPRMachineState *spapr, uint64_t buid,
|
2015-05-07 08:33:34 +03:00
|
|
|
uint32_t config_addr)
|
2012-08-07 20:10:35 +04:00
|
|
|
{
|
2015-05-07 08:33:34 +03:00
|
|
|
sPAPRPHBState *sphb = spapr_pci_find_phb(spapr, buid);
|
2012-08-20 21:08:08 +04:00
|
|
|
PCIHostState *phb = PCI_HOST_BRIDGE(sphb);
|
2013-08-21 10:02:15 +04:00
|
|
|
int bus_num = (config_addr >> 16) & 0xFF;
|
2012-08-07 20:10:35 +04:00
|
|
|
int devfn = (config_addr >> 8) & 0xFF;
|
|
|
|
|
|
|
|
if (!phb) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2013-08-21 10:02:15 +04:00
|
|
|
return pci_find_device(phb->bus, bus_num, devfn);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2012-01-11 23:46:25 +04:00
|
|
|
static uint32_t rtas_pci_cfgaddr(uint32_t arg)
|
|
|
|
{
|
2012-04-02 08:17:35 +04:00
|
|
|
/* This handles the encoding of extended config space addresses */
|
2012-01-11 23:46:25 +04:00
|
|
|
return ((arg >> 20) & 0xf00) | (arg & 0xff);
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void finish_read_pci_config(sPAPRMachineState *spapr, uint64_t buid,
|
2012-04-02 08:17:35 +04:00
|
|
|
uint32_t addr, uint32_t size,
|
|
|
|
target_ulong rets)
|
2012-01-18 19:42:09 +04:00
|
|
|
{
|
2012-04-02 08:17:35 +04:00
|
|
|
PCIDevice *pci_dev;
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
if ((size != 1) && (size != 2) && (size != 4)) {
|
|
|
|
/* access must be 1, 2 or 4 bytes */
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-04-02 08:17:35 +04:00
|
|
|
return;
|
2012-01-18 19:42:09 +04:00
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:34 +03:00
|
|
|
pci_dev = spapr_pci_find_dev(spapr, buid, addr);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_pci_cfgaddr(addr);
|
|
|
|
|
|
|
|
if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
|
|
|
|
/* Access must be to a valid device, within bounds and
|
|
|
|
* naturally aligned */
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-04-02 08:17:35 +04:00
|
|
|
return;
|
2012-01-18 19:42:09 +04:00
|
|
|
}
|
2012-04-02 08:17:35 +04:00
|
|
|
|
|
|
|
val = pci_host_config_read_common(pci_dev, addr,
|
|
|
|
pci_config_size(pci_dev), size);
|
|
|
|
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
2012-04-02 08:17:35 +04:00
|
|
|
rtas_st(rets, 1, val);
|
2012-01-18 19:42:09 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void rtas_ibm_read_pci_config(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args,
|
|
|
|
uint32_t nret, target_ulong rets)
|
|
|
|
{
|
2012-04-02 08:17:35 +04:00
|
|
|
uint64_t buid;
|
|
|
|
uint32_t size, addr;
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-04-02 08:17:35 +04:00
|
|
|
if ((nargs != 4) || (nret != 2)) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2011-10-30 21:16:46 +04:00
|
|
|
return;
|
|
|
|
}
|
2012-04-02 08:17:35 +04:00
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2011-10-30 21:16:46 +04:00
|
|
|
size = rtas_ld(args, 3);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_ld(args, 0);
|
|
|
|
|
|
|
|
finish_read_pci_config(spapr, buid, addr, size, rets);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void rtas_read_pci_config(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args,
|
|
|
|
uint32_t nret, target_ulong rets)
|
|
|
|
{
|
2012-04-02 08:17:35 +04:00
|
|
|
uint32_t size, addr;
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-04-02 08:17:35 +04:00
|
|
|
if ((nargs != 2) || (nret != 2)) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2011-10-30 21:16:46 +04:00
|
|
|
return;
|
|
|
|
}
|
2012-04-02 08:17:35 +04:00
|
|
|
|
2011-10-30 21:16:46 +04:00
|
|
|
size = rtas_ld(args, 1);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_ld(args, 0);
|
|
|
|
|
|
|
|
finish_read_pci_config(spapr, 0, addr, size, rets);
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void finish_write_pci_config(sPAPRMachineState *spapr, uint64_t buid,
|
2012-04-02 08:17:35 +04:00
|
|
|
uint32_t addr, uint32_t size,
|
|
|
|
uint32_t val, target_ulong rets)
|
|
|
|
{
|
|
|
|
PCIDevice *pci_dev;
|
|
|
|
|
|
|
|
if ((size != 1) && (size != 2) && (size != 4)) {
|
|
|
|
/* access must be 1, 2 or 4 bytes */
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-04-02 08:17:35 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:34 +03:00
|
|
|
pci_dev = spapr_pci_find_dev(spapr, buid, addr);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_pci_cfgaddr(addr);
|
|
|
|
|
|
|
|
if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
|
|
|
|
/* Access must be to a valid device, within bounds and
|
|
|
|
* naturally aligned */
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-04-02 08:17:35 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_host_config_write_common(pci_dev, addr, pci_config_size(pci_dev),
|
|
|
|
val, size);
|
|
|
|
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void rtas_ibm_write_pci_config(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args,
|
|
|
|
uint32_t nret, target_ulong rets)
|
|
|
|
{
|
2012-04-02 08:17:35 +04:00
|
|
|
uint64_t buid;
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t val, size, addr;
|
|
|
|
|
2012-04-02 08:17:35 +04:00
|
|
|
if ((nargs != 5) || (nret != 1)) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2011-10-30 21:16:46 +04:00
|
|
|
return;
|
|
|
|
}
|
2012-04-02 08:17:35 +04:00
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2011-10-30 21:16:46 +04:00
|
|
|
val = rtas_ld(args, 4);
|
|
|
|
size = rtas_ld(args, 3);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_ld(args, 0);
|
|
|
|
|
|
|
|
finish_write_pci_config(spapr, buid, addr, size, val, rets);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void rtas_write_pci_config(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args,
|
|
|
|
uint32_t nret, target_ulong rets)
|
|
|
|
{
|
|
|
|
uint32_t val, size, addr;
|
|
|
|
|
2012-04-02 08:17:35 +04:00
|
|
|
if ((nargs != 3) || (nret != 1)) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2011-10-30 21:16:46 +04:00
|
|
|
return;
|
|
|
|
}
|
2012-04-02 08:17:35 +04:00
|
|
|
|
|
|
|
|
2011-10-30 21:16:46 +04:00
|
|
|
val = rtas_ld(args, 2);
|
|
|
|
size = rtas_ld(args, 1);
|
2012-04-02 08:17:35 +04:00
|
|
|
addr = rtas_ld(args, 0);
|
|
|
|
|
|
|
|
finish_write_pci_config(spapr, 0, addr, size, val, rets);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:37 +04:00
|
|
|
/*
|
|
|
|
* Set MSI/MSIX message data.
|
|
|
|
* This is required for msi_notify()/msix_notify() which
|
|
|
|
* will write at the addresses via spapr_msi_write().
|
2014-05-30 13:34:20 +04:00
|
|
|
*
|
|
|
|
* If hwaddr == 0, all entries will have .data == first_irq i.e.
|
|
|
|
* table will be reset.
|
2012-08-07 20:10:37 +04:00
|
|
|
*/
|
2013-07-12 11:38:24 +04:00
|
|
|
static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix,
|
|
|
|
unsigned first_irq, unsigned req_num)
|
2012-08-07 20:10:37 +04:00
|
|
|
{
|
|
|
|
unsigned i;
|
2013-07-12 11:38:24 +04:00
|
|
|
MSIMessage msg = { .address = addr, .data = first_irq };
|
2012-08-07 20:10:37 +04:00
|
|
|
|
|
|
|
if (!msix) {
|
|
|
|
msi_set_message(pdev, msg);
|
|
|
|
trace_spapr_pci_msi_setup(pdev->name, 0, msg.address);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
for (i = 0; i < req_num; ++i) {
|
2012-08-07 20:10:37 +04:00
|
|
|
msix_set_message(pdev, i, msg);
|
|
|
|
trace_spapr_pci_msi_setup(pdev->name, i, msg.address);
|
2014-05-30 13:34:20 +04:00
|
|
|
if (addr) {
|
|
|
|
++msg.data;
|
|
|
|
}
|
2012-08-07 20:10:37 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
static void rtas_ibm_change_msi(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
2012-08-07 20:10:37 +04:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
uint32_t config_addr = rtas_ld(args, 0);
|
2015-09-01 04:05:12 +03:00
|
|
|
uint64_t buid = rtas_ldq(args, 1);
|
2012-08-07 20:10:37 +04:00
|
|
|
unsigned int func = rtas_ld(args, 3);
|
|
|
|
unsigned int req_num = rtas_ld(args, 4); /* 0 == remove all */
|
|
|
|
unsigned int seq_num = rtas_ld(args, 5);
|
|
|
|
unsigned int ret_intr_type;
|
2016-02-25 21:02:12 +03:00
|
|
|
unsigned int irq, max_irqs = 0;
|
2012-08-07 20:10:37 +04:00
|
|
|
sPAPRPHBState *phb = NULL;
|
|
|
|
PCIDevice *pdev = NULL;
|
2014-05-30 13:34:20 +04:00
|
|
|
spapr_pci_msi *msi;
|
|
|
|
int *config_addr_key;
|
2016-02-26 12:44:07 +03:00
|
|
|
Error *err = NULL;
|
2012-08-07 20:10:37 +04:00
|
|
|
|
|
|
|
switch (func) {
|
|
|
|
case RTAS_CHANGE_MSI_FN:
|
|
|
|
case RTAS_CHANGE_FN:
|
|
|
|
ret_intr_type = RTAS_TYPE_MSI;
|
|
|
|
break;
|
|
|
|
case RTAS_CHANGE_MSIX_FN:
|
|
|
|
ret_intr_type = RTAS_TYPE_MSIX;
|
|
|
|
break;
|
|
|
|
default:
|
2013-11-21 08:08:58 +04:00
|
|
|
error_report("rtas_ibm_change_msi(%u) is not implemented", func);
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fins sPAPRPHBState */
|
2015-05-07 08:33:34 +03:00
|
|
|
phb = spapr_pci_find_phb(spapr, buid);
|
2012-08-07 20:10:37 +04:00
|
|
|
if (phb) {
|
2015-05-07 08:33:34 +03:00
|
|
|
pdev = spapr_pci_find_dev(spapr, buid, config_addr);
|
2012-08-07 20:10:37 +04:00
|
|
|
}
|
|
|
|
if (!phb || !pdev) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-02-25 21:02:18 +03:00
|
|
|
msi = (spapr_pci_msi *) g_hash_table_lookup(phb->msi, &config_addr);
|
|
|
|
|
2012-08-07 20:10:37 +04:00
|
|
|
/* Releasing MSIs */
|
|
|
|
if (!req_num) {
|
2014-05-30 13:34:20 +04:00
|
|
|
if (!msi) {
|
|
|
|
trace_spapr_pci_msi("Releasing wrong config", config_addr);
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
2014-05-30 13:34:20 +04:00
|
|
|
|
2016-06-28 22:05:15 +03:00
|
|
|
xics_spapr_free(spapr->xics, msi->first_irq, msi->num);
|
2014-08-13 11:20:53 +04:00
|
|
|
if (msi_present(pdev)) {
|
2016-02-25 21:02:12 +03:00
|
|
|
spapr_msi_setmsg(pdev, 0, false, 0, 0);
|
2014-08-13 11:20:53 +04:00
|
|
|
}
|
|
|
|
if (msix_present(pdev)) {
|
2016-02-25 21:02:12 +03:00
|
|
|
spapr_msi_setmsg(pdev, 0, true, 0, 0);
|
2014-08-13 11:20:53 +04:00
|
|
|
}
|
2014-05-30 13:34:20 +04:00
|
|
|
g_hash_table_remove(phb->msi, &config_addr);
|
|
|
|
|
|
|
|
trace_spapr_pci_msi("Released MSIs", config_addr);
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
2012-08-07 20:10:37 +04:00
|
|
|
rtas_st(rets, 1, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enabling MSI */
|
|
|
|
|
2014-05-04 18:09:48 +04:00
|
|
|
/* Check if the device supports as many IRQs as requested */
|
|
|
|
if (ret_intr_type == RTAS_TYPE_MSI) {
|
|
|
|
max_irqs = msi_nr_vectors_allocated(pdev);
|
|
|
|
} else if (ret_intr_type == RTAS_TYPE_MSIX) {
|
|
|
|
max_irqs = pdev->msix_entries_nr;
|
|
|
|
}
|
|
|
|
if (!max_irqs) {
|
2014-05-30 13:34:20 +04:00
|
|
|
error_report("Requested interrupt type %d is not enabled for device %x",
|
|
|
|
ret_intr_type, config_addr);
|
2014-05-04 18:09:48 +04:00
|
|
|
rtas_st(rets, 0, -1); /* Hardware error */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Correct the number if the guest asked for too many */
|
|
|
|
if (req_num > max_irqs) {
|
2014-05-30 13:34:20 +04:00
|
|
|
trace_spapr_pci_msi_retry(config_addr, req_num, max_irqs);
|
2014-05-04 18:09:48 +04:00
|
|
|
req_num = max_irqs;
|
2014-05-30 13:34:20 +04:00
|
|
|
irq = 0; /* to avoid misleading trace */
|
|
|
|
goto out;
|
2014-05-04 18:09:48 +04:00
|
|
|
}
|
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
/* Allocate MSIs */
|
2016-10-03 10:24:46 +03:00
|
|
|
irq = xics_spapr_alloc_block(spapr->xics, req_num, false,
|
2016-02-26 12:44:07 +03:00
|
|
|
ret_intr_type == RTAS_TYPE_MSI, &err);
|
|
|
|
if (err) {
|
|
|
|
error_reportf_err(err, "Can't allocate MSIs for device %x: ",
|
|
|
|
config_addr);
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-02-25 21:02:18 +03:00
|
|
|
/* Release previous MSIs */
|
|
|
|
if (msi) {
|
2016-06-28 22:05:15 +03:00
|
|
|
xics_spapr_free(spapr->xics, msi->first_irq, msi->num);
|
2016-02-25 21:02:18 +03:00
|
|
|
g_hash_table_remove(phb->msi, &config_addr);
|
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:37 +04:00
|
|
|
/* Setup MSI/MSIX vectors in the device (via cfgspace or MSIX BAR) */
|
2014-08-27 20:17:12 +04:00
|
|
|
spapr_msi_setmsg(pdev, SPAPR_PCI_MSI_WINDOW, ret_intr_type == RTAS_TYPE_MSIX,
|
2014-05-30 13:34:20 +04:00
|
|
|
irq, req_num);
|
2012-08-07 20:10:37 +04:00
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
/* Add MSI device to cache */
|
|
|
|
msi = g_new(spapr_pci_msi, 1);
|
|
|
|
msi->first_irq = irq;
|
|
|
|
msi->num = req_num;
|
|
|
|
config_addr_key = g_new(int, 1);
|
|
|
|
*config_addr_key = config_addr;
|
|
|
|
g_hash_table_insert(phb->msi, config_addr_key, msi);
|
|
|
|
|
|
|
|
out:
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
2012-08-07 20:10:37 +04:00
|
|
|
rtas_st(rets, 1, req_num);
|
|
|
|
rtas_st(rets, 2, ++seq_num);
|
2015-09-01 04:23:47 +03:00
|
|
|
if (nret > 3) {
|
|
|
|
rtas_st(rets, 3, ret_intr_type);
|
|
|
|
}
|
2012-08-07 20:10:37 +04:00
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
trace_spapr_pci_rtas_ibm_change_msi(config_addr, func, req_num, irq);
|
2012-08-07 20:10:37 +04:00
|
|
|
}
|
|
|
|
|
2013-06-20 00:40:30 +04:00
|
|
|
static void rtas_ibm_query_interrupt_source_number(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2012-08-07 20:10:37 +04:00
|
|
|
uint32_t token,
|
|
|
|
uint32_t nargs,
|
|
|
|
target_ulong args,
|
|
|
|
uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
uint32_t config_addr = rtas_ld(args, 0);
|
2015-09-01 04:05:12 +03:00
|
|
|
uint64_t buid = rtas_ldq(args, 1);
|
2012-08-07 20:10:37 +04:00
|
|
|
unsigned int intr_src_num = -1, ioa_intr_num = rtas_ld(args, 3);
|
|
|
|
sPAPRPHBState *phb = NULL;
|
2014-05-30 13:34:20 +04:00
|
|
|
PCIDevice *pdev = NULL;
|
|
|
|
spapr_pci_msi *msi;
|
2012-08-07 20:10:37 +04:00
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
/* Find sPAPRPHBState */
|
2015-05-07 08:33:34 +03:00
|
|
|
phb = spapr_pci_find_phb(spapr, buid);
|
2014-05-30 13:34:20 +04:00
|
|
|
if (phb) {
|
2015-05-07 08:33:34 +03:00
|
|
|
pdev = spapr_pci_find_dev(spapr, buid, config_addr);
|
2014-05-30 13:34:20 +04:00
|
|
|
}
|
|
|
|
if (!phb || !pdev) {
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find device descriptor and start IRQ */
|
2014-05-30 13:34:20 +04:00
|
|
|
msi = (spapr_pci_msi *) g_hash_table_lookup(phb->msi, &config_addr);
|
|
|
|
if (!msi || !msi->first_irq || !msi->num || (ioa_intr_num >= msi->num)) {
|
|
|
|
trace_spapr_pci_msi("Failed to return vector", config_addr);
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
|
2012-08-07 20:10:37 +04:00
|
|
|
return;
|
|
|
|
}
|
2014-05-30 13:34:20 +04:00
|
|
|
intr_src_num = msi->first_irq + ioa_intr_num;
|
2012-08-07 20:10:37 +04:00
|
|
|
trace_spapr_pci_rtas_ibm_query_interrupt_source_number(ioa_intr_num,
|
|
|
|
intr_src_num);
|
|
|
|
|
2013-11-19 08:28:54 +04:00
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
2012-08-07 20:10:37 +04:00
|
|
|
rtas_st(rets, 1, intr_src_num);
|
|
|
|
rtas_st(rets, 2, 1);/* 0 == level; 1 == edge */
|
|
|
|
}
|
|
|
|
|
2015-02-20 07:58:52 +03:00
|
|
|
static void rtas_ibm_set_eeh_option(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
uint32_t addr, option;
|
|
|
|
uint64_t buid;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((nargs != 4) || (nret != 1)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-02-20 07:58:52 +03:00
|
|
|
addr = rtas_ld(args, 0);
|
|
|
|
option = rtas_ld(args, 3);
|
|
|
|
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
ret = spapr_phb_vfio_eeh_set_option(sphb, addr, option);
|
2015-02-20 07:58:52 +03:00
|
|
|
rtas_st(rets, 0, ret);
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtas_ibm_get_config_addr_info2(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
PCIDevice *pdev;
|
|
|
|
uint32_t addr, option;
|
|
|
|
uint64_t buid;
|
|
|
|
|
|
|
|
if ((nargs != 4) || (nret != 2)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We always have PE address of form "00BB0001". "BB"
|
|
|
|
* represents the bus number of PE's primary bus.
|
|
|
|
*/
|
|
|
|
option = rtas_ld(args, 3);
|
|
|
|
switch (option) {
|
|
|
|
case RTAS_GET_PE_ADDR:
|
|
|
|
addr = rtas_ld(args, 0);
|
2015-05-07 08:33:34 +03:00
|
|
|
pdev = spapr_pci_find_dev(spapr, buid, addr);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!pdev) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
rtas_st(rets, 1, (pci_bus_num(pdev->bus) << 16) + 1);
|
|
|
|
break;
|
|
|
|
case RTAS_GET_PE_MODE:
|
|
|
|
rtas_st(rets, 1, RTAS_PE_MODE_SHARED);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_SUCCESS);
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtas_ibm_read_slot_reset_state2(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
uint64_t buid;
|
|
|
|
int state, ret;
|
|
|
|
|
|
|
|
if ((nargs != 3) || (nret != 4 && nret != 5)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
ret = spapr_phb_vfio_eeh_get_state(sphb, &state);
|
2015-02-20 07:58:52 +03:00
|
|
|
rtas_st(rets, 0, ret);
|
|
|
|
if (ret != RTAS_OUT_SUCCESS) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rtas_st(rets, 1, state);
|
|
|
|
rtas_st(rets, 2, RTAS_EEH_SUPPORT);
|
|
|
|
rtas_st(rets, 3, RTAS_EEH_PE_UNAVAIL_INFO);
|
|
|
|
if (nret >= 5) {
|
|
|
|
rtas_st(rets, 4, RTAS_EEH_PE_RECOVER_INFO);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtas_ibm_set_slot_reset(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
uint32_t option;
|
|
|
|
uint64_t buid;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((nargs != 4) || (nret != 1)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-02-20 07:58:52 +03:00
|
|
|
option = rtas_ld(args, 3);
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
ret = spapr_phb_vfio_eeh_reset(sphb, option);
|
2015-02-20 07:58:52 +03:00
|
|
|
rtas_st(rets, 0, ret);
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtas_ibm_configure_pe(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
uint64_t buid;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((nargs != 3) || (nret != 1)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
ret = spapr_phb_vfio_eeh_configure(sphb);
|
2015-02-20 07:58:52 +03:00
|
|
|
rtas_st(rets, 0, ret);
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* To support it later */
|
|
|
|
static void rtas_ibm_slot_error_detail(PowerPCCPU *cpu,
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr,
|
2015-02-20 07:58:52 +03:00
|
|
|
uint32_t token, uint32_t nargs,
|
|
|
|
target_ulong args, uint32_t nret,
|
|
|
|
target_ulong rets)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
int option;
|
|
|
|
uint64_t buid;
|
|
|
|
|
|
|
|
if ((nargs != 8) || (nret != 1)) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2015-09-01 04:05:12 +03:00
|
|
|
buid = rtas_ldq(args, 1);
|
2015-05-07 08:33:34 +03:00
|
|
|
sphb = spapr_pci_find_phb(spapr, buid);
|
2015-02-20 07:58:52 +03:00
|
|
|
if (!sphb) {
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
2016-02-29 09:45:05 +03:00
|
|
|
if (!spapr_phb_eeh_available(sphb)) {
|
2015-02-20 07:58:52 +03:00
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
option = rtas_ld(args, 7);
|
|
|
|
switch (option) {
|
|
|
|
case RTAS_SLOT_TEMP_ERR_LOG:
|
|
|
|
case RTAS_SLOT_PERM_ERR_LOG:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto param_error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't have error log yet */
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_NO_ERRORS_FOUND);
|
|
|
|
return;
|
|
|
|
|
|
|
|
param_error_exit:
|
|
|
|
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
|
|
|
|
}
|
|
|
|
|
2012-04-25 21:55:42 +04:00
|
|
|
static int pci_spapr_swizzle(int slot, int pin)
|
|
|
|
{
|
|
|
|
return (slot + pin) % PCI_NUM_PINS;
|
|
|
|
}
|
|
|
|
|
2011-10-30 21:16:46 +04:00
|
|
|
static int pci_spapr_map_irq(PCIDevice *pci_dev, int irq_num)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Here we need to convert pci_dev + irq_num to some unique value
|
2012-04-25 21:55:42 +04:00
|
|
|
* which is less than number of IRQs on the specific bus (4). We
|
|
|
|
* use standard PCI swizzling, that is (slot number + pin number)
|
|
|
|
* % 4.
|
2011-10-30 21:16:46 +04:00
|
|
|
*/
|
2012-04-25 21:55:42 +04:00
|
|
|
return pci_spapr_swizzle(PCI_SLOT(pci_dev->devfn), irq_num);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Here we use the number returned by pci_spapr_map_irq to find a
|
|
|
|
* corresponding qemu_irq.
|
|
|
|
*/
|
|
|
|
sPAPRPHBState *phb = opaque;
|
|
|
|
|
2013-01-23 21:20:39 +04:00
|
|
|
trace_spapr_pci_lsi_set(phb->dtbusname, irq_num, phb->lsi_table[irq_num].irq);
|
2012-08-07 20:10:32 +04:00
|
|
|
qemu_set_irq(spapr_phb_lsi_qirq(phb, irq_num), level);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2013-09-26 10:18:48 +04:00
|
|
|
static PCIINTxRoute spapr_route_intx_pin_to_irq(void *opaque, int pin)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(opaque);
|
|
|
|
PCIINTxRoute route;
|
|
|
|
|
|
|
|
route.mode = PCI_INTX_ENABLED;
|
|
|
|
route.irq = sphb->lsi_table[pin].irq;
|
|
|
|
|
|
|
|
return route;
|
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:37 +04:00
|
|
|
/*
|
|
|
|
* MSI/MSIX memory region implementation.
|
|
|
|
* The handler handles both MSI and MSIX.
|
|
|
|
* For MSI-X, the vector number is encoded as a part of the address,
|
|
|
|
* data is set to 0.
|
|
|
|
* For MSI, the vector number is encoded in least bits in data.
|
|
|
|
*/
|
2012-10-23 14:30:10 +04:00
|
|
|
static void spapr_msi_write(void *opaque, hwaddr addr,
|
2012-08-07 20:10:37 +04:00
|
|
|
uint64_t data, unsigned size)
|
|
|
|
{
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
|
2013-07-12 11:38:24 +04:00
|
|
|
uint32_t irq = data;
|
2012-08-07 20:10:37 +04:00
|
|
|
|
|
|
|
trace_spapr_pci_msi_write(addr, data, irq);
|
|
|
|
|
2016-06-28 22:05:15 +03:00
|
|
|
qemu_irq_pulse(xics_get_qirq(spapr->xics, irq));
|
2012-08-07 20:10:37 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static const MemoryRegionOps spapr_msi_ops = {
|
|
|
|
/* There is no .read as the read result is undefined by PCI spec */
|
|
|
|
.read = NULL,
|
|
|
|
.write = spapr_msi_write,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN
|
|
|
|
};
|
|
|
|
|
2012-03-12 21:50:24 +04:00
|
|
|
/*
|
|
|
|
* PHB PCI device
|
|
|
|
*/
|
2012-10-30 15:47:48 +04:00
|
|
|
static AddressSpace *spapr_pci_dma_iommu(PCIBus *bus, void *opaque, int devfn)
|
2012-06-27 08:50:46 +04:00
|
|
|
{
|
|
|
|
sPAPRPHBState *phb = opaque;
|
|
|
|
|
2012-10-30 15:47:48 +04:00
|
|
|
return &phb->iommu_as;
|
2012-06-27 08:50:46 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:22 +03:00
|
|
|
static char *spapr_phb_vfio_get_loc_code(sPAPRPHBState *sphb, PCIDevice *pdev)
|
|
|
|
{
|
|
|
|
char *path = NULL, *buf = NULL, *host = NULL;
|
|
|
|
|
|
|
|
/* Get the PCI VFIO host id */
|
|
|
|
host = object_property_get_str(OBJECT(pdev), "host", NULL);
|
|
|
|
if (!host) {
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Construct the path of the file that will give us the DT location */
|
|
|
|
path = g_strdup_printf("/sys/bus/pci/devices/%s/devspec", host);
|
|
|
|
g_free(host);
|
|
|
|
if (!path || !g_file_get_contents(path, &buf, NULL, NULL)) {
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
g_free(path);
|
|
|
|
|
|
|
|
/* Construct and read from host device tree the loc-code */
|
|
|
|
path = g_strdup_printf("/proc/device-tree%s/ibm,loc-code", buf);
|
|
|
|
g_free(buf);
|
|
|
|
if (!path || !g_file_get_contents(path, &buf, NULL, NULL)) {
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
g_free(path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *spapr_phb_get_loc_code(sPAPRPHBState *sphb, PCIDevice *pdev)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
const char *devtype = "qemu";
|
|
|
|
uint32_t busnr = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(pdev))));
|
|
|
|
|
|
|
|
if (object_dynamic_cast(OBJECT(pdev), "vfio-pci")) {
|
|
|
|
buf = spapr_phb_vfio_get_loc_code(sphb, pdev);
|
|
|
|
if (buf) {
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
devtype = "vfio";
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* For emulated devices and VFIO-failure case, make up
|
|
|
|
* the loc-code.
|
|
|
|
*/
|
|
|
|
buf = g_strdup_printf("%s_%s:%04x:%02x:%02x.%x",
|
|
|
|
devtype, pdev->name, sphb->index, busnr,
|
|
|
|
PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
/* Macros to operate with address in OF binding to PCI */
|
|
|
|
#define b_x(x, p, l) (((x) & ((1<<(l))-1)) << (p))
|
|
|
|
#define b_n(x) b_x((x), 31, 1) /* 0 if relocatable */
|
|
|
|
#define b_p(x) b_x((x), 30, 1) /* 1 if prefetchable */
|
|
|
|
#define b_t(x) b_x((x), 29, 1) /* 1 if the address is aliased */
|
|
|
|
#define b_ss(x) b_x((x), 24, 2) /* the space code */
|
|
|
|
#define b_bbbbbbbb(x) b_x((x), 16, 8) /* bus number */
|
|
|
|
#define b_ddddd(x) b_x((x), 11, 5) /* device number */
|
|
|
|
#define b_fff(x) b_x((x), 8, 3) /* function number */
|
|
|
|
#define b_rrrrrrrr(x) b_x((x), 0, 8) /* register number */
|
|
|
|
|
|
|
|
/* for 'reg'/'assigned-addresses' OF properties */
|
|
|
|
#define RESOURCE_CELLS_SIZE 2
|
|
|
|
#define RESOURCE_CELLS_ADDRESS 3
|
|
|
|
|
|
|
|
typedef struct ResourceFields {
|
|
|
|
uint32_t phys_hi;
|
|
|
|
uint32_t phys_mid;
|
|
|
|
uint32_t phys_lo;
|
|
|
|
uint32_t size_hi;
|
|
|
|
uint32_t size_lo;
|
|
|
|
} QEMU_PACKED ResourceFields;
|
|
|
|
|
|
|
|
typedef struct ResourceProps {
|
|
|
|
ResourceFields reg[8];
|
|
|
|
ResourceFields assigned[7];
|
|
|
|
uint32_t reg_len;
|
|
|
|
uint32_t assigned_len;
|
|
|
|
} ResourceProps;
|
|
|
|
|
|
|
|
/* fill in the 'reg'/'assigned-resources' OF properties for
|
|
|
|
* a PCI device. 'reg' describes resource requirements for a
|
|
|
|
* device's IO/MEM regions, 'assigned-addresses' describes the
|
|
|
|
* actual resource assignments.
|
|
|
|
*
|
|
|
|
* the properties are arrays of ('phys-addr', 'size') pairs describing
|
|
|
|
* the addressable regions of the PCI device, where 'phys-addr' is a
|
|
|
|
* RESOURCE_CELLS_ADDRESS-tuple of 32-bit integers corresponding to
|
|
|
|
* (phys.hi, phys.mid, phys.lo), and 'size' is a
|
|
|
|
* RESOURCE_CELLS_SIZE-tuple corresponding to (size.hi, size.lo).
|
|
|
|
*
|
|
|
|
* phys.hi = 0xYYXXXXZZ, where:
|
|
|
|
* 0xYY = npt000ss
|
|
|
|
* ||| |
|
2015-07-02 09:23:08 +03:00
|
|
|
* ||| +-- space code
|
|
|
|
* ||| |
|
|
|
|
* ||| + 00 if configuration space
|
|
|
|
* ||| + 01 if IO region,
|
|
|
|
* ||| + 10 if 32-bit MEM region
|
|
|
|
* ||| + 11 if 64-bit MEM region
|
|
|
|
* |||
|
2015-05-07 08:33:55 +03:00
|
|
|
* ||+------ for non-relocatable IO: 1 if aliased
|
|
|
|
* || for relocatable IO: 1 if below 64KB
|
|
|
|
* || for MEM: 1 if below 1MB
|
|
|
|
* |+------- 1 if region is prefetchable
|
|
|
|
* +-------- 1 if region is non-relocatable
|
|
|
|
* 0xXXXX = bbbbbbbb dddddfff, encoding bus, slot, and function
|
|
|
|
* bits respectively
|
|
|
|
* 0xZZ = rrrrrrrr, the register number of the BAR corresponding
|
|
|
|
* to the region
|
|
|
|
*
|
|
|
|
* phys.mid and phys.lo correspond respectively to the hi/lo portions
|
|
|
|
* of the actual address of the region.
|
|
|
|
*
|
|
|
|
* how the phys-addr/size values are used differ slightly between
|
|
|
|
* 'reg' and 'assigned-addresses' properties. namely, 'reg' has
|
|
|
|
* an additional description for the config space region of the
|
|
|
|
* device, and in the case of QEMU has n=0 and phys.mid=phys.lo=0
|
|
|
|
* to describe the region as relocatable, with an address-mapping
|
|
|
|
* that corresponds directly to the PHB's address space for the
|
|
|
|
* resource. 'assigned-addresses' always has n=1 set with an absolute
|
|
|
|
* address assigned for the resource. in general, 'assigned-addresses'
|
|
|
|
* won't be populated, since addresses for PCI devices are generally
|
|
|
|
* unmapped initially and left to the guest to assign.
|
|
|
|
*
|
|
|
|
* note also that addresses defined in these properties are, at least
|
|
|
|
* for PAPR guests, relative to the PHBs IO/MEM windows, and
|
|
|
|
* correspond directly to the addresses in the BARs.
|
|
|
|
*
|
|
|
|
* in accordance with PCI Bus Binding to Open Firmware,
|
|
|
|
* IEEE Std 1275-1994, section 4.1.1, as implemented by PAPR+ v2.7,
|
|
|
|
* Appendix C.
|
|
|
|
*/
|
|
|
|
static void populate_resource_props(PCIDevice *d, ResourceProps *rp)
|
|
|
|
{
|
|
|
|
int bus_num = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(d))));
|
|
|
|
uint32_t dev_id = (b_bbbbbbbb(bus_num) |
|
|
|
|
b_ddddd(PCI_SLOT(d->devfn)) |
|
|
|
|
b_fff(PCI_FUNC(d->devfn)));
|
|
|
|
ResourceFields *reg, *assigned;
|
|
|
|
int i, reg_idx = 0, assigned_idx = 0;
|
|
|
|
|
|
|
|
/* config space region */
|
|
|
|
reg = &rp->reg[reg_idx++];
|
|
|
|
reg->phys_hi = cpu_to_be32(dev_id);
|
|
|
|
reg->phys_mid = 0;
|
|
|
|
reg->phys_lo = 0;
|
|
|
|
reg->size_hi = 0;
|
|
|
|
reg->size_lo = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < PCI_NUM_REGIONS; i++) {
|
|
|
|
if (!d->io_regions[i].size) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
reg = &rp->reg[reg_idx++];
|
|
|
|
|
|
|
|
reg->phys_hi = cpu_to_be32(dev_id | b_rrrrrrrr(pci_bar(d, i)));
|
|
|
|
if (d->io_regions[i].type & PCI_BASE_ADDRESS_SPACE_IO) {
|
|
|
|
reg->phys_hi |= cpu_to_be32(b_ss(1));
|
2015-07-02 09:23:08 +03:00
|
|
|
} else if (d->io_regions[i].type & PCI_BASE_ADDRESS_MEM_TYPE_64) {
|
|
|
|
reg->phys_hi |= cpu_to_be32(b_ss(3));
|
2015-05-07 08:33:55 +03:00
|
|
|
} else {
|
|
|
|
reg->phys_hi |= cpu_to_be32(b_ss(2));
|
|
|
|
}
|
|
|
|
reg->phys_mid = 0;
|
|
|
|
reg->phys_lo = 0;
|
|
|
|
reg->size_hi = cpu_to_be32(d->io_regions[i].size >> 32);
|
|
|
|
reg->size_lo = cpu_to_be32(d->io_regions[i].size);
|
|
|
|
|
|
|
|
if (d->io_regions[i].addr == PCI_BAR_UNMAPPED) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
assigned = &rp->assigned[assigned_idx++];
|
|
|
|
assigned->phys_hi = cpu_to_be32(reg->phys_hi | b_n(1));
|
|
|
|
assigned->phys_mid = cpu_to_be32(d->io_regions[i].addr >> 32);
|
|
|
|
assigned->phys_lo = cpu_to_be32(d->io_regions[i].addr);
|
|
|
|
assigned->size_hi = reg->size_hi;
|
|
|
|
assigned->size_lo = reg->size_lo;
|
|
|
|
}
|
|
|
|
|
|
|
|
rp->reg_len = reg_idx * sizeof(ResourceFields);
|
|
|
|
rp->assigned_len = assigned_idx * sizeof(ResourceFields);
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:23 +03:00
|
|
|
static uint32_t spapr_phb_get_pci_drc_index(sPAPRPHBState *phb,
|
|
|
|
PCIDevice *pdev);
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
static int spapr_populate_pci_child_dt(PCIDevice *dev, void *fdt, int offset,
|
2015-07-02 09:23:22 +03:00
|
|
|
sPAPRPHBState *sphb)
|
2015-05-07 08:33:55 +03:00
|
|
|
{
|
|
|
|
ResourceProps rp;
|
|
|
|
bool is_bridge = false;
|
2015-07-02 09:23:22 +03:00
|
|
|
int pci_status, err;
|
|
|
|
char *buf = NULL;
|
2015-07-02 09:23:23 +03:00
|
|
|
uint32_t drc_index = spapr_phb_get_pci_drc_index(sphb, dev);
|
spapr_pci: fix device tree props for MSI/MSI-X
PAPR requires ibm,req#msi and ibm,req#msi-x to be present in the
device node to define the number of msi/msi-x interrupts the device
supports, respectively.
Currently we have ibm,req#msi-x hardcoded to a non-sensical constant
that happens to be 2, and are missing ibm,req#msi entirely. The result
of that is that msi-x capable devices get limited to 2 msi-x
interrupts (which can impact performance), and msi-only devices likely
wouldn't work at all. Additionally, if devices expect a minimum that
exceeds 2, the guest driver may fail to load entirely.
SLOF still owns the generation of these properties at boot-time
(although other device properties have since been offloaded to QEMU),
but for hotplugged devices we rely on the values generated by QEMU
and thus hit the limitations above.
Fix this by generating these properties in QEMU as expected by guests.
In the future it may make sense to modify SLOF to pass through these
values directly as we do with other props since we're duplicating SLOF
code.
Cc: qemu-ppc@nongnu.org
Cc: qemu-stable@nongnu.org
Cc: David Gibson <david@gibson.dropbear.id.au>
Cc: Nikunj A Dadhania <nikunj@linux.vnet.ibm.com>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2015-09-16 00:34:59 +03:00
|
|
|
uint32_t max_msi, max_msix;
|
2015-05-07 08:33:55 +03:00
|
|
|
|
|
|
|
if (pci_default_read_config(dev, PCI_HEADER_TYPE, 1) ==
|
|
|
|
PCI_HEADER_TYPE_BRIDGE) {
|
|
|
|
is_bridge = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* in accordance with PAPR+ v2.7 13.6.3, Table 181 */
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "vendor-id",
|
|
|
|
pci_default_read_config(dev, PCI_VENDOR_ID, 2)));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "device-id",
|
|
|
|
pci_default_read_config(dev, PCI_DEVICE_ID, 2)));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "revision-id",
|
|
|
|
pci_default_read_config(dev, PCI_REVISION_ID, 1)));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "class-code",
|
2015-07-02 09:23:09 +03:00
|
|
|
pci_default_read_config(dev, PCI_CLASS_PROG, 3)));
|
2015-05-07 08:33:55 +03:00
|
|
|
if (pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "interrupts",
|
|
|
|
pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_bridge) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "min-grant",
|
|
|
|
pci_default_read_config(dev, PCI_MIN_GNT, 1)));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "max-latency",
|
|
|
|
pci_default_read_config(dev, PCI_MAX_LAT, 1)));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-id",
|
|
|
|
pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-vendor-id",
|
|
|
|
pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)));
|
|
|
|
}
|
|
|
|
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "cache-line-size",
|
|
|
|
pci_default_read_config(dev, PCI_CACHE_LINE_SIZE, 1)));
|
|
|
|
|
|
|
|
/* the following fdt cells are masked off the pci status register */
|
|
|
|
pci_status = pci_default_read_config(dev, PCI_STATUS, 2);
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "devsel-speed",
|
|
|
|
PCI_STATUS_DEVSEL_MASK & pci_status));
|
|
|
|
|
|
|
|
if (pci_status & PCI_STATUS_FAST_BACK) {
|
|
|
|
_FDT(fdt_setprop(fdt, offset, "fast-back-to-back", NULL, 0));
|
|
|
|
}
|
|
|
|
if (pci_status & PCI_STATUS_66MHZ) {
|
|
|
|
_FDT(fdt_setprop(fdt, offset, "66mhz-capable", NULL, 0));
|
|
|
|
}
|
|
|
|
if (pci_status & PCI_STATUS_UDF) {
|
|
|
|
_FDT(fdt_setprop(fdt, offset, "udf-supported", NULL, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* NOTE: this is normally generated by firmware via path/unit name,
|
|
|
|
* but in our case we must set it manually since it does not get
|
|
|
|
* processed by OF beforehand
|
|
|
|
*/
|
|
|
|
_FDT(fdt_setprop_string(fdt, offset, "name", "pci"));
|
2015-07-02 09:23:22 +03:00
|
|
|
buf = spapr_phb_get_loc_code(sphb, dev);
|
|
|
|
if (!buf) {
|
|
|
|
error_report("Failed setting the ibm,loc-code");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = fdt_setprop_string(fdt, offset, "ibm,loc-code", buf);
|
|
|
|
g_free(buf);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:23 +03:00
|
|
|
if (drc_index) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index));
|
|
|
|
}
|
2015-05-07 08:33:55 +03:00
|
|
|
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "#address-cells",
|
|
|
|
RESOURCE_CELLS_ADDRESS));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "#size-cells",
|
|
|
|
RESOURCE_CELLS_SIZE));
|
spapr_pci: fix device tree props for MSI/MSI-X
PAPR requires ibm,req#msi and ibm,req#msi-x to be present in the
device node to define the number of msi/msi-x interrupts the device
supports, respectively.
Currently we have ibm,req#msi-x hardcoded to a non-sensical constant
that happens to be 2, and are missing ibm,req#msi entirely. The result
of that is that msi-x capable devices get limited to 2 msi-x
interrupts (which can impact performance), and msi-only devices likely
wouldn't work at all. Additionally, if devices expect a minimum that
exceeds 2, the guest driver may fail to load entirely.
SLOF still owns the generation of these properties at boot-time
(although other device properties have since been offloaded to QEMU),
but for hotplugged devices we rely on the values generated by QEMU
and thus hit the limitations above.
Fix this by generating these properties in QEMU as expected by guests.
In the future it may make sense to modify SLOF to pass through these
values directly as we do with other props since we're duplicating SLOF
code.
Cc: qemu-ppc@nongnu.org
Cc: qemu-stable@nongnu.org
Cc: David Gibson <david@gibson.dropbear.id.au>
Cc: Nikunj A Dadhania <nikunj@linux.vnet.ibm.com>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2015-09-16 00:34:59 +03:00
|
|
|
|
|
|
|
max_msi = msi_nr_vectors_allocated(dev);
|
|
|
|
if (max_msi) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi", max_msi));
|
|
|
|
}
|
|
|
|
max_msix = dev->msix_entries_nr;
|
|
|
|
if (max_msix) {
|
|
|
|
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi-x", max_msix));
|
|
|
|
}
|
2015-05-07 08:33:55 +03:00
|
|
|
|
|
|
|
populate_resource_props(dev, &rp);
|
|
|
|
_FDT(fdt_setprop(fdt, offset, "reg", (uint8_t *)rp.reg, rp.reg_len));
|
|
|
|
_FDT(fdt_setprop(fdt, offset, "assigned-addresses",
|
|
|
|
(uint8_t *)rp.assigned, rp.assigned_len));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create OF node for pci device and required OF DT properties */
|
2015-07-02 09:23:21 +03:00
|
|
|
static int spapr_create_pci_child_dt(sPAPRPHBState *phb, PCIDevice *dev,
|
|
|
|
void *fdt, int node_offset)
|
2015-05-07 08:33:55 +03:00
|
|
|
{
|
2015-07-02 09:23:21 +03:00
|
|
|
int offset, ret;
|
2015-05-07 08:33:55 +03:00
|
|
|
int slot = PCI_SLOT(dev->devfn);
|
|
|
|
int func = PCI_FUNC(dev->devfn);
|
2015-07-02 09:23:10 +03:00
|
|
|
char nodename[FDT_NAME_MAX];
|
2015-05-07 08:33:55 +03:00
|
|
|
|
|
|
|
if (func != 0) {
|
2015-07-02 09:23:10 +03:00
|
|
|
snprintf(nodename, FDT_NAME_MAX, "pci@%x,%x", slot, func);
|
2015-05-07 08:33:55 +03:00
|
|
|
} else {
|
2015-07-02 09:23:10 +03:00
|
|
|
snprintf(nodename, FDT_NAME_MAX, "pci@%x", slot);
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
2015-07-02 09:23:21 +03:00
|
|
|
offset = fdt_add_subnode(fdt, node_offset, nodename);
|
2015-07-02 09:23:23 +03:00
|
|
|
ret = spapr_populate_pci_child_dt(dev, fdt, offset, phb);
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
g_assert(!ret);
|
2015-07-02 09:23:21 +03:00
|
|
|
if (ret) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return offset;
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_add_pci_device(sPAPRDRConnector *drc,
|
|
|
|
sPAPRPHBState *phb,
|
|
|
|
PCIDevice *pdev,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
|
|
|
|
DeviceState *dev = DEVICE(pdev);
|
|
|
|
void *fdt = NULL;
|
2015-07-02 09:23:21 +03:00
|
|
|
int fdt_start_offset = 0, fdt_size;
|
2015-05-07 08:33:55 +03:00
|
|
|
|
2016-05-24 20:55:04 +03:00
|
|
|
fdt = create_device_tree(&fdt_size);
|
|
|
|
fdt_start_offset = spapr_create_pci_child_dt(phb, pdev, fdt, 0);
|
|
|
|
if (!fdt_start_offset) {
|
|
|
|
error_setg(errp, "Failed to create pci child device tree node");
|
|
|
|
goto out;
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
drck->attach(drc, DEVICE(pdev),
|
|
|
|
fdt, fdt_start_offset, !dev->hotplugged, errp);
|
2015-07-02 09:23:21 +03:00
|
|
|
out:
|
2015-05-07 08:33:55 +03:00
|
|
|
if (*errp) {
|
|
|
|
g_free(fdt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_remove_pci_device_cb(DeviceState *dev, void *opaque)
|
|
|
|
{
|
|
|
|
/* some version guests do not wait for completion of a device
|
|
|
|
* cleanup (generally done asynchronously by the kernel) before
|
|
|
|
* signaling to QEMU that the device is safe, but instead sleep
|
|
|
|
* for some 'safe' period of time. unfortunately on a busy host
|
|
|
|
* this sleep isn't guaranteed to be long enough, resulting in
|
|
|
|
* bad things like IRQ lines being left asserted during final
|
|
|
|
* device removal. to deal with this we call reset just prior
|
|
|
|
* to finalizing the device, which will put the device back into
|
|
|
|
* an 'idle' state, as the device cleanup code expects.
|
|
|
|
*/
|
|
|
|
pci_device_reset(PCI_DEVICE(dev));
|
|
|
|
object_unparent(OBJECT(dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_remove_pci_device(sPAPRDRConnector *drc,
|
|
|
|
sPAPRPHBState *phb,
|
|
|
|
PCIDevice *pdev,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
|
|
|
|
|
|
|
|
drck->detach(drc, DEVICE(pdev), spapr_phb_remove_pci_device_cb, phb, errp);
|
|
|
|
}
|
|
|
|
|
2016-03-04 00:55:36 +03:00
|
|
|
static sPAPRDRConnector *spapr_phb_get_pci_func_drc(sPAPRPHBState *phb,
|
|
|
|
uint32_t busnr,
|
|
|
|
int32_t devfn)
|
2015-05-07 08:33:55 +03:00
|
|
|
{
|
|
|
|
return spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_PCI,
|
|
|
|
(phb->index << 16) |
|
|
|
|
(busnr << 8) |
|
2016-03-04 00:55:36 +03:00
|
|
|
devfn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static sPAPRDRConnector *spapr_phb_get_pci_drc(sPAPRPHBState *phb,
|
|
|
|
PCIDevice *pdev)
|
|
|
|
{
|
|
|
|
uint32_t busnr = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(pdev))));
|
|
|
|
return spapr_phb_get_pci_func_drc(phb, busnr, pdev->devfn);
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:21 +03:00
|
|
|
static uint32_t spapr_phb_get_pci_drc_index(sPAPRPHBState *phb,
|
|
|
|
PCIDevice *pdev)
|
|
|
|
{
|
|
|
|
sPAPRDRConnector *drc = spapr_phb_get_pci_drc(phb, pdev);
|
|
|
|
sPAPRDRConnectorClass *drck;
|
|
|
|
|
|
|
|
if (!drc) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
|
|
|
|
return drck->get_index(drc);
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
static void spapr_phb_hot_plug_child(HotplugHandler *plug_handler,
|
|
|
|
DeviceState *plugged_dev, Error **errp)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
|
|
|
|
PCIDevice *pdev = PCI_DEVICE(plugged_dev);
|
|
|
|
sPAPRDRConnector *drc = spapr_phb_get_pci_drc(phb, pdev);
|
|
|
|
Error *local_err = NULL;
|
2016-03-04 00:55:36 +03:00
|
|
|
PCIBus *bus = PCI_BUS(qdev_get_parent_bus(DEVICE(pdev)));
|
|
|
|
uint32_t slotnr = PCI_SLOT(pdev->devfn);
|
2015-05-07 08:33:55 +03:00
|
|
|
|
|
|
|
/* if DR is disabled we don't need to do anything in the case of
|
|
|
|
* hotplug or coldplug callbacks
|
|
|
|
*/
|
|
|
|
if (!phb->dr_enabled) {
|
|
|
|
/* if this is a hotplug operation initiated by the user
|
|
|
|
* we need to let them know it's not enabled
|
|
|
|
*/
|
|
|
|
if (plugged_dev->hotplugged) {
|
2015-03-17 13:54:50 +03:00
|
|
|
error_setg(errp, QERR_BUS_NO_HOTPLUG,
|
|
|
|
object_get_typename(OBJECT(phb)));
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert(drc);
|
|
|
|
|
2016-03-04 00:55:36 +03:00
|
|
|
/* Following the QEMU convention used for PCIe multifunction
|
|
|
|
* hotplug, we do not allow functions to be hotplugged to a
|
|
|
|
* slot that already has function 0 present
|
|
|
|
*/
|
|
|
|
if (plugged_dev->hotplugged && bus->devices[PCI_DEVFN(slotnr, 0)] &&
|
|
|
|
PCI_FUNC(pdev->devfn) != 0) {
|
|
|
|
error_setg(errp, "PCI: slot %d function 0 already ocuppied by %s,"
|
|
|
|
" additional functions can no longer be exposed to guest.",
|
|
|
|
slotnr, bus->devices[PCI_DEVFN(slotnr, 0)]->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
spapr_phb_add_pci_device(drc, phb, pdev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2016-03-04 00:55:36 +03:00
|
|
|
|
|
|
|
/* If this is function 0, signal hotplug for all the device functions.
|
|
|
|
* Otherwise defer sending the hotplug event.
|
|
|
|
*/
|
|
|
|
if (plugged_dev->hotplugged && PCI_FUNC(pdev->devfn) == 0) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
sPAPRDRConnector *func_drc;
|
|
|
|
sPAPRDRConnectorClass *func_drck;
|
|
|
|
sPAPRDREntitySense state;
|
|
|
|
|
|
|
|
func_drc = spapr_phb_get_pci_func_drc(phb, pci_bus_num(bus),
|
|
|
|
PCI_DEVFN(slotnr, i));
|
|
|
|
func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
|
|
|
|
func_drck->entity_sense(func_drc, &state);
|
|
|
|
|
|
|
|
if (state == SPAPR_DR_ENTITY_SENSE_PRESENT) {
|
|
|
|
spapr_hotplug_req_add_by_index(func_drc);
|
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:33:56 +03:00
|
|
|
}
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_hot_unplug_child(HotplugHandler *plug_handler,
|
|
|
|
DeviceState *plugged_dev, Error **errp)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
|
|
|
|
PCIDevice *pdev = PCI_DEVICE(plugged_dev);
|
|
|
|
sPAPRDRConnectorClass *drck;
|
|
|
|
sPAPRDRConnector *drc = spapr_phb_get_pci_drc(phb, pdev);
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
if (!phb->dr_enabled) {
|
2015-03-17 13:54:50 +03:00
|
|
|
error_setg(errp, QERR_BUS_NO_HOTPLUG,
|
|
|
|
object_get_typename(OBJECT(phb)));
|
2015-05-07 08:33:55 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert(drc);
|
|
|
|
|
|
|
|
drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
|
|
|
|
if (!drck->release_pending(drc)) {
|
2016-03-04 00:55:36 +03:00
|
|
|
PCIBus *bus = PCI_BUS(qdev_get_parent_bus(DEVICE(pdev)));
|
|
|
|
uint32_t slotnr = PCI_SLOT(pdev->devfn);
|
|
|
|
sPAPRDRConnector *func_drc;
|
|
|
|
sPAPRDRConnectorClass *func_drck;
|
|
|
|
sPAPRDREntitySense state;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* ensure any other present functions are pending unplug */
|
|
|
|
if (PCI_FUNC(pdev->devfn) == 0) {
|
|
|
|
for (i = 1; i < 8; i++) {
|
|
|
|
func_drc = spapr_phb_get_pci_func_drc(phb, pci_bus_num(bus),
|
|
|
|
PCI_DEVFN(slotnr, i));
|
|
|
|
func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
|
|
|
|
func_drck->entity_sense(func_drc, &state);
|
|
|
|
if (state == SPAPR_DR_ENTITY_SENSE_PRESENT
|
|
|
|
&& !func_drck->release_pending(func_drc)) {
|
|
|
|
error_setg(errp,
|
|
|
|
"PCI: slot %d, function %d still present. "
|
|
|
|
"Must unplug all non-0 functions first.",
|
|
|
|
slotnr, i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:55 +03:00
|
|
|
spapr_phb_remove_pci_device(drc, phb, pdev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2016-03-04 00:55:36 +03:00
|
|
|
|
|
|
|
/* if this isn't func 0, defer unplug event. otherwise signal removal
|
|
|
|
* for all present functions
|
|
|
|
*/
|
|
|
|
if (PCI_FUNC(pdev->devfn) == 0) {
|
|
|
|
for (i = 7; i >= 0; i--) {
|
|
|
|
func_drc = spapr_phb_get_pci_func_drc(phb, pci_bus_num(bus),
|
|
|
|
PCI_DEVFN(slotnr, i));
|
|
|
|
func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
|
|
|
|
func_drck->entity_sense(func_drc, &state);
|
|
|
|
if (state == SPAPR_DR_ENTITY_SENSE_PRESENT) {
|
|
|
|
spapr_hotplug_req_remove_by_index(func_drc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:33:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-21 08:08:55 +04:00
|
|
|
static void spapr_phb_realize(DeviceState *dev, Error **errp)
|
2011-10-30 21:16:46 +04:00
|
|
|
{
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
|
2013-11-21 08:08:55 +04:00
|
|
|
SysBusDevice *s = SYS_BUS_DEVICE(dev);
|
2012-08-20 21:08:05 +04:00
|
|
|
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
|
2012-08-20 21:08:08 +04:00
|
|
|
PCIHostState *phb = PCI_HOST_BRIDGE(s);
|
2012-03-12 21:50:24 +04:00
|
|
|
char *namebuf;
|
|
|
|
int i;
|
2011-10-30 21:16:46 +04:00
|
|
|
PCIBus *bus;
|
2014-08-27 20:17:12 +04:00
|
|
|
uint64_t msi_window_size = 4096;
|
2016-02-29 09:20:00 +03:00
|
|
|
sPAPRTCETable *tcet;
|
2016-07-04 06:33:07 +03:00
|
|
|
const unsigned windows_supported =
|
|
|
|
sphb->ddw_enabled ? SPAPR_PCI_DMA_MAX_WINDOWS : 1;
|
2011-10-30 21:16:46 +04:00
|
|
|
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
if (sphb->index != (uint32_t)-1) {
|
spapr_pci: Delegate placement of PCI host bridges to machine type
The 'spapr-pci-host-bridge' represents the virtual PCI host bridge (PHB)
for a PAPR guest. Unlike on x86, it's routine on Power (both bare metal
and PAPR guests) to have numerous independent PHBs, each controlling a
separate PCI domain.
There are two ways of configuring the spapr-pci-host-bridge device: first
it can be done fully manually, specifying the locations and sizes of all
the IO windows. This gives the most control, but is very awkward with 6
mandatory parameters. Alternatively just an "index" can be specified
which essentially selects from an array of predefined PHB locations.
The PHB at index 0 is automatically created as the default PHB.
The current set of default locations causes some problems for guests with
large RAM (> 1 TiB) or PCI devices with very large BARs (e.g. big nVidia
GPGPU cards via VFIO). Obviously, for migration we can only change the
locations on a new machine type, however.
This is awkward, because the placement is currently decided within the
spapr-pci-host-bridge code, so it breaks abstraction to look inside the
machine type version.
So, this patch delegates the "default mode" PHB placement from the
spapr-pci-host-bridge device back to the machine type via a public method
in sPAPRMachineClass. It's still a bit ugly, but it's about the best we
can do.
For now, this just changes where the calculation is done. It doesn't
change the actual location of the host bridges, or any other behaviour.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-13 02:26:09 +03:00
|
|
|
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
|
|
|
|
Error *local_err = NULL;
|
2013-01-23 21:20:39 +04:00
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn[0] != (uint32_t)-1)
|
|
|
|
|| (sphb->dma_liobn[1] != (uint32_t)-1 && windows_supported == 2)
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
|| (sphb->mem_win_addr != (hwaddr)-1)
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
|| (sphb->mem64_win_addr != (hwaddr)-1)
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
|| (sphb->io_win_addr != (hwaddr)-1)) {
|
2013-11-21 08:08:55 +04:00
|
|
|
error_setg(errp, "Either \"index\" or other parameters must"
|
|
|
|
" be specified for PAPR PHB, not both");
|
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
smc->phb_placement(spapr, sphb->index,
|
|
|
|
&sphb->buid, &sphb->io_win_addr,
|
|
|
|
&sphb->mem_win_addr, &sphb->mem64_win_addr,
|
spapr_pci: Delegate placement of PCI host bridges to machine type
The 'spapr-pci-host-bridge' represents the virtual PCI host bridge (PHB)
for a PAPR guest. Unlike on x86, it's routine on Power (both bare metal
and PAPR guests) to have numerous independent PHBs, each controlling a
separate PCI domain.
There are two ways of configuring the spapr-pci-host-bridge device: first
it can be done fully manually, specifying the locations and sizes of all
the IO windows. This gives the most control, but is very awkward with 6
mandatory parameters. Alternatively just an "index" can be specified
which essentially selects from an array of predefined PHB locations.
The PHB at index 0 is automatically created as the default PHB.
The current set of default locations causes some problems for guests with
large RAM (> 1 TiB) or PCI devices with very large BARs (e.g. big nVidia
GPGPU cards via VFIO). Obviously, for migration we can only change the
locations on a new machine type, however.
This is awkward, because the placement is currently decided within the
spapr-pci-host-bridge code, so it breaks abstraction to look inside the
machine type version.
So, this patch delegates the "default mode" PHB placement from the
spapr-pci-host-bridge device back to the machine type via a public method
in sPAPRMachineClass. It's still a bit ugly, but it's about the best we
can do.
For now, this just changes where the calculation is done. It doesn't
change the actual location of the host bridges, or any other behaviour.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-13 02:26:09 +03:00
|
|
|
windows_supported, sphb->dma_liobn, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2015-01-14 05:33:39 +03:00
|
|
|
return;
|
|
|
|
}
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
if (sphb->buid == (uint64_t)-1) {
|
2013-11-21 08:08:55 +04:00
|
|
|
error_setg(errp, "BUID not specified for PHB");
|
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
if ((sphb->dma_liobn[0] == (uint32_t)-1) ||
|
|
|
|
((sphb->dma_liobn[1] == (uint32_t)-1) && (windows_supported > 1))) {
|
|
|
|
error_setg(errp, "LIOBN(s) not specified for PHB");
|
2013-11-21 08:08:55 +04:00
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
if (sphb->mem_win_addr == (hwaddr)-1) {
|
2013-11-21 08:08:55 +04:00
|
|
|
error_setg(errp, "Memory window address not specified for PHB");
|
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
spapr_pci: Fix unsafe signed/unsigned comparisons
spapr_pci.c contains a number of expressions of the form (uval == -1) or
(uval != -1), where 'uval' is an unsigned value.
This mostly works in practice, because as long as the width of uval is
greater or equal than that of (int), the -1 will be promoted to the
unsigned type, which is the expected outcome.
However, at least for the cases where uval is uint32_t, this would break
on platforms where sizeof(int) > 4 (and a few such do exist), because then
the uint32_t value would be promoted to the larger int type, and never be
equal to -1.
This patch fixes these errors. The fixes for the (uint32_t) cases are
necessary as described above. I've made similar fixes to (uint64_t) and
(hwaddr) cases. Those are strictly theoretical, since I don't know of any
platforms where sizeof(int) > 8, but hey, it's not that hard so we might
as well be strictly C standard compliant.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-03-19 07:14:18 +03:00
|
|
|
if (sphb->io_win_addr == (hwaddr)-1) {
|
2013-11-21 08:08:55 +04:00
|
|
|
error_setg(errp, "IO window address not specified for PHB");
|
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
if (sphb->mem64_win_size != 0) {
|
|
|
|
if (sphb->mem64_win_addr == (hwaddr)-1) {
|
|
|
|
error_setg(errp,
|
|
|
|
"64-bit memory window address not specified for PHB");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
|
|
|
|
error_setg(errp, "32-bit memory window of size 0x%"HWADDR_PRIx
|
|
|
|
" (max 2 GiB)", sphb->mem_win_size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sphb->mem64_win_pciaddr == (hwaddr)-1) {
|
|
|
|
/* 64-bit window defaults to identity mapping */
|
|
|
|
sphb->mem64_win_pciaddr = sphb->mem64_win_addr;
|
|
|
|
}
|
|
|
|
} else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
|
|
|
|
/*
|
|
|
|
* For compatibility with old configuration, if no 64-bit MMIO
|
|
|
|
* window is specified, but the ordinary (32-bit) memory
|
|
|
|
* window is specified as > 2GiB, we treat it as a 2GiB 32-bit
|
|
|
|
* window, with a 64-bit MMIO window following on immediately
|
|
|
|
* afterwards
|
|
|
|
*/
|
|
|
|
sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;
|
|
|
|
sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;
|
|
|
|
sphb->mem64_win_pciaddr =
|
|
|
|
SPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;
|
|
|
|
sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;
|
|
|
|
}
|
|
|
|
|
2015-05-07 08:33:34 +03:00
|
|
|
if (spapr_pci_find_phb(spapr, sphb->buid)) {
|
2013-11-21 08:08:55 +04:00
|
|
|
error_setg(errp, "PCI host bridges must have unique BUIDs");
|
|
|
|
return;
|
2013-01-23 21:20:39 +04:00
|
|
|
}
|
|
|
|
|
2016-10-18 23:50:23 +03:00
|
|
|
if (sphb->numa_node != -1 &&
|
|
|
|
(sphb->numa_node >= MAX_NODES || !numa_info[sphb->numa_node].present)) {
|
|
|
|
error_setg(errp, "Invalid NUMA node ID for PCI host bridge");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
|
2013-01-23 21:20:39 +04:00
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
namebuf = alloca(strlen(sphb->dtbusname) + 32);
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-03-12 21:50:24 +04:00
|
|
|
/* Initialize memory regions */
|
2012-08-20 21:08:05 +04:00
|
|
|
sprintf(namebuf, "%s.mmio", sphb->dtbusname);
|
2013-11-06 22:25:21 +04:00
|
|
|
memory_region_init(&sphb->memspace, OBJECT(sphb), namebuf, UINT64_MAX);
|
2011-10-30 21:16:46 +04:00
|
|
|
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
sprintf(namebuf, "%s.mmio32-alias", sphb->dtbusname);
|
|
|
|
memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),
|
2013-06-07 05:25:08 +04:00
|
|
|
namebuf, &sphb->memspace,
|
2012-08-20 21:08:05 +04:00
|
|
|
SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
|
|
|
|
memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
&sphb->mem32window);
|
|
|
|
|
|
|
|
sprintf(namebuf, "%s.mmio64-alias", sphb->dtbusname);
|
|
|
|
memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),
|
|
|
|
namebuf, &sphb->memspace,
|
|
|
|
sphb->mem64_win_pciaddr, sphb->mem64_win_size);
|
|
|
|
memory_region_add_subregion(get_system_memory(), sphb->mem64_win_addr,
|
|
|
|
&sphb->mem64window);
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2014-02-07 17:44:17 +04:00
|
|
|
/* Initialize IO regions */
|
2012-08-20 21:08:05 +04:00
|
|
|
sprintf(namebuf, "%s.io", sphb->dtbusname);
|
2013-06-07 05:25:08 +04:00
|
|
|
memory_region_init(&sphb->iospace, OBJECT(sphb),
|
|
|
|
namebuf, SPAPR_PCI_IO_WIN_SIZE);
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-10-29 21:24:57 +04:00
|
|
|
sprintf(namebuf, "%s.io-alias", sphb->dtbusname);
|
2013-07-22 17:54:14 +04:00
|
|
|
memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), namebuf,
|
2014-02-07 17:44:17 +04:00
|
|
|
&sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
|
2012-08-20 21:08:05 +04:00
|
|
|
memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
|
2012-10-29 21:24:57 +04:00
|
|
|
&sphb->iowindow);
|
2014-03-06 07:11:00 +04:00
|
|
|
|
|
|
|
bus = pci_register_bus(dev, NULL,
|
2012-08-20 21:08:05 +04:00
|
|
|
pci_spapr_set_irq, pci_spapr_map_irq, sphb,
|
|
|
|
&sphb->memspace, &sphb->iospace,
|
2013-03-15 02:01:11 +04:00
|
|
|
PCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);
|
2012-08-20 21:08:05 +04:00
|
|
|
phb->bus = bus;
|
2015-05-07 08:33:55 +03:00
|
|
|
qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);
|
2012-03-12 21:50:24 +04:00
|
|
|
|
2014-05-27 09:36:32 +04:00
|
|
|
/*
|
|
|
|
* Initialize PHB address space.
|
|
|
|
* By default there will be at least one subregion for default
|
|
|
|
* 32bit DMA window.
|
|
|
|
* Later the guest might want to create another DMA window
|
|
|
|
* which will become another memory subregion.
|
|
|
|
*/
|
|
|
|
sprintf(namebuf, "%s.iommu-root", sphb->dtbusname);
|
|
|
|
|
|
|
|
memory_region_init(&sphb->iommu_root, OBJECT(sphb),
|
|
|
|
namebuf, UINT64_MAX);
|
|
|
|
address_space_init(&sphb->iommu_as, &sphb->iommu_root,
|
|
|
|
sphb->dtbusname);
|
|
|
|
|
2014-08-27 20:17:12 +04:00
|
|
|
/*
|
|
|
|
* As MSI/MSIX interrupts trigger by writing at MSI/MSIX vectors,
|
|
|
|
* we need to allocate some memory to catch those writes coming
|
|
|
|
* from msi_notify()/msix_notify().
|
|
|
|
* As MSIMessage:addr is going to be the same and MSIMessage:data
|
|
|
|
* is going to be a VIRQ number, 4 bytes of the MSI MR will only
|
|
|
|
* be used.
|
|
|
|
*
|
|
|
|
* For KVM we want to ensure that this memory is a full page so that
|
|
|
|
* our memory slot is of page size granularity.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_KVM
|
|
|
|
if (kvm_enabled()) {
|
|
|
|
msi_window_size = getpagesize();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
memory_region_init_io(&sphb->msiwindow, NULL, &spapr_msi_ops, spapr,
|
|
|
|
"msi", msi_window_size);
|
|
|
|
memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
|
|
|
|
&sphb->msiwindow);
|
|
|
|
|
2012-10-30 15:47:48 +04:00
|
|
|
pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
|
2012-06-27 08:50:46 +04:00
|
|
|
|
2013-09-26 10:18:48 +04:00
|
|
|
pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
|
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
|
2012-03-12 21:50:24 +04:00
|
|
|
|
|
|
|
/* Initialize the LSI table */
|
2012-04-25 21:55:42 +04:00
|
|
|
for (i = 0; i < PCI_NUM_PINS; i++) {
|
2012-08-07 20:10:32 +04:00
|
|
|
uint32_t irq;
|
2016-02-26 12:44:07 +03:00
|
|
|
Error *local_err = NULL;
|
2012-03-12 21:50:24 +04:00
|
|
|
|
2016-10-03 10:24:46 +03:00
|
|
|
irq = xics_spapr_alloc_block(spapr->xics, 1, true, false, &local_err);
|
2016-02-26 12:44:07 +03:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
error_prepend(errp, "can't allocate LSIs: ");
|
2013-11-21 08:08:55 +04:00
|
|
|
return;
|
2012-03-12 21:50:24 +04:00
|
|
|
}
|
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
sphb->lsi_table[i].irq = irq;
|
2012-03-12 21:50:24 +04:00
|
|
|
}
|
2014-05-27 09:36:31 +04:00
|
|
|
|
2015-05-07 08:33:53 +03:00
|
|
|
/* allocate connectors for child PCI devices */
|
|
|
|
if (sphb->dr_enabled) {
|
|
|
|
for (i = 0; i < PCI_SLOT_MAX * 8; i++) {
|
|
|
|
spapr_dr_connector_new(OBJECT(phb),
|
|
|
|
SPAPR_DR_CONNECTOR_TYPE_PCI,
|
|
|
|
(sphb->index << 16) | i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
/* DMA setup */
|
|
|
|
for (i = 0; i < windows_supported; ++i) {
|
|
|
|
tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[i]);
|
|
|
|
if (!tcet) {
|
|
|
|
error_setg(errp, "Creating window#%d failed for %s",
|
|
|
|
i, sphb->dtbusname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memory_region_add_subregion_overlap(&sphb->iommu_root, 0,
|
|
|
|
spapr_tce_get_iommu(tcet), 0);
|
2014-05-27 09:36:31 +04:00
|
|
|
}
|
2014-05-27 09:36:32 +04:00
|
|
|
|
2016-02-29 09:20:00 +03:00
|
|
|
sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
|
2012-03-12 21:50:24 +04:00
|
|
|
}
|
|
|
|
|
2014-05-27 09:36:33 +04:00
|
|
|
static int spapr_phb_children_reset(Object *child, void *opaque)
|
2012-09-12 20:57:14 +04:00
|
|
|
{
|
2014-05-27 09:36:33 +04:00
|
|
|
DeviceState *dev = (DeviceState *) object_dynamic_cast(child, TYPE_DEVICE);
|
|
|
|
|
|
|
|
if (dev) {
|
|
|
|
device_reset(dev);
|
|
|
|
}
|
2012-09-12 20:57:14 +04:00
|
|
|
|
2014-05-27 09:36:33 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-01 11:57:39 +03:00
|
|
|
void spapr_phb_dma_reset(sPAPRPHBState *sphb)
|
2014-05-27 09:36:33 +04:00
|
|
|
{
|
2016-07-04 06:33:07 +03:00
|
|
|
int i;
|
|
|
|
sPAPRTCETable *tcet;
|
|
|
|
|
|
|
|
for (i = 0; i < SPAPR_PCI_DMA_MAX_WINDOWS; ++i) {
|
|
|
|
tcet = spapr_tce_find_by_liobn(sphb->dma_liobn[i]);
|
2016-06-01 11:57:36 +03:00
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
if (tcet && tcet->nb_table) {
|
|
|
|
spapr_tce_table_disable(tcet);
|
|
|
|
}
|
2016-06-01 11:57:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Register default 32bit DMA window */
|
2016-07-04 06:33:07 +03:00
|
|
|
tcet = spapr_tce_find_by_liobn(sphb->dma_liobn[0]);
|
2016-06-01 11:57:36 +03:00
|
|
|
spapr_tce_table_enable(tcet, SPAPR_TCE_PAGE_SHIFT, sphb->dma_win_addr,
|
|
|
|
sphb->dma_win_size >> SPAPR_TCE_PAGE_SHIFT);
|
2016-06-01 11:57:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_reset(DeviceState *qdev)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(qdev);
|
|
|
|
|
|
|
|
spapr_phb_dma_reset(sphb);
|
2016-06-01 11:57:36 +03:00
|
|
|
|
2012-09-12 20:57:14 +04:00
|
|
|
/* Reset the IOMMU state */
|
2014-05-27 09:36:33 +04:00
|
|
|
object_child_foreach(OBJECT(qdev), spapr_phb_children_reset, NULL);
|
2016-02-29 09:45:05 +03:00
|
|
|
|
|
|
|
if (spapr_phb_eeh_available(SPAPR_PCI_HOST_BRIDGE(qdev))) {
|
|
|
|
spapr_phb_vfio_reset(qdev);
|
|
|
|
}
|
2012-09-12 20:57:14 +04:00
|
|
|
}
|
|
|
|
|
2012-03-12 21:50:24 +04:00
|
|
|
static Property spapr_phb_properties[] = {
|
2015-01-14 05:33:39 +03:00
|
|
|
DEFINE_PROP_UINT32("index", sPAPRPHBState, index, -1),
|
2014-02-08 14:01:53 +04:00
|
|
|
DEFINE_PROP_UINT64("buid", sPAPRPHBState, buid, -1),
|
2016-07-04 06:33:07 +03:00
|
|
|
DEFINE_PROP_UINT32("liobn", sPAPRPHBState, dma_liobn[0], -1),
|
|
|
|
DEFINE_PROP_UINT32("liobn64", sPAPRPHBState, dma_liobn[1], -1),
|
2014-02-08 14:01:53 +04:00
|
|
|
DEFINE_PROP_UINT64("mem_win_addr", sPAPRPHBState, mem_win_addr, -1),
|
|
|
|
DEFINE_PROP_UINT64("mem_win_size", sPAPRPHBState, mem_win_size,
|
2016-10-16 04:04:15 +03:00
|
|
|
SPAPR_PCI_MEM32_WIN_SIZE),
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
DEFINE_PROP_UINT64("mem64_win_addr", sPAPRPHBState, mem64_win_addr, -1),
|
2016-10-16 04:04:15 +03:00
|
|
|
DEFINE_PROP_UINT64("mem64_win_size", sPAPRPHBState, mem64_win_size,
|
|
|
|
SPAPR_PCI_MEM64_WIN_SIZE),
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
DEFINE_PROP_UINT64("mem64_win_pciaddr", sPAPRPHBState, mem64_win_pciaddr,
|
|
|
|
-1),
|
2014-02-08 14:01:53 +04:00
|
|
|
DEFINE_PROP_UINT64("io_win_addr", sPAPRPHBState, io_win_addr, -1),
|
|
|
|
DEFINE_PROP_UINT64("io_win_size", sPAPRPHBState, io_win_size,
|
|
|
|
SPAPR_PCI_IO_WIN_SIZE),
|
2015-05-07 08:33:52 +03:00
|
|
|
DEFINE_PROP_BOOL("dynamic-reconfiguration", sPAPRPHBState, dr_enabled,
|
|
|
|
true),
|
2015-09-24 02:56:44 +03:00
|
|
|
/* Default DMA window is 0..1GB */
|
|
|
|
DEFINE_PROP_UINT64("dma_win_addr", sPAPRPHBState, dma_win_addr, 0),
|
|
|
|
DEFINE_PROP_UINT64("dma_win_size", sPAPRPHBState, dma_win_size, 0x40000000),
|
2016-07-04 06:33:07 +03:00
|
|
|
DEFINE_PROP_UINT64("dma64_win_addr", sPAPRPHBState, dma64_win_addr,
|
|
|
|
0x800000000000000ULL),
|
|
|
|
DEFINE_PROP_BOOL("ddw", sPAPRPHBState, ddw_enabled, true),
|
|
|
|
DEFINE_PROP_UINT64("pgsz", sPAPRPHBState, page_size_mask,
|
|
|
|
(1ULL << 12) | (1ULL << 16)),
|
2016-07-27 11:03:38 +03:00
|
|
|
DEFINE_PROP_UINT32("numa_node", sPAPRPHBState, numa_node, -1),
|
2016-11-23 02:26:38 +03:00
|
|
|
DEFINE_PROP_BOOL("pre-2.8-migration", sPAPRPHBState,
|
|
|
|
pre_2_8_migration, false),
|
2012-03-12 21:50:24 +04:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2013-07-18 23:33:02 +04:00
|
|
|
static const VMStateDescription vmstate_spapr_pci_lsi = {
|
|
|
|
.name = "spapr_pci/lsi",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 17:24:04 +04:00
|
|
|
.fields = (VMStateField[]) {
|
2013-07-18 23:33:02 +04:00
|
|
|
VMSTATE_UINT32_EQUAL(irq, struct spapr_pci_lsi),
|
|
|
|
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const VMStateDescription vmstate_spapr_pci_msi = {
|
2014-05-30 13:34:20 +04:00
|
|
|
.name = "spapr_pci/msi",
|
2013-07-18 23:33:02 +04:00
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-05-30 13:34:20 +04:00
|
|
|
.fields = (VMStateField []) {
|
|
|
|
VMSTATE_UINT32(key, spapr_pci_msi_mig),
|
|
|
|
VMSTATE_UINT32(value.first_irq, spapr_pci_msi_mig),
|
|
|
|
VMSTATE_UINT32(value.num, spapr_pci_msi_mig),
|
2013-07-18 23:33:02 +04:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2014-05-30 13:34:20 +04:00
|
|
|
static void spapr_pci_pre_save(void *opaque)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = opaque;
|
2015-07-02 09:23:13 +03:00
|
|
|
GHashTableIter iter;
|
|
|
|
gpointer key, value;
|
|
|
|
int i;
|
2014-05-30 13:34:20 +04:00
|
|
|
|
2015-08-26 15:02:53 +03:00
|
|
|
g_free(sphb->msi_devs);
|
|
|
|
sphb->msi_devs = NULL;
|
2015-07-02 09:23:13 +03:00
|
|
|
sphb->msi_devs_num = g_hash_table_size(sphb->msi);
|
|
|
|
if (!sphb->msi_devs_num) {
|
2014-05-30 13:34:20 +04:00
|
|
|
return;
|
|
|
|
}
|
2015-07-02 09:23:13 +03:00
|
|
|
sphb->msi_devs = g_malloc(sphb->msi_devs_num * sizeof(spapr_pci_msi_mig));
|
2014-05-30 13:34:20 +04:00
|
|
|
|
2015-07-02 09:23:13 +03:00
|
|
|
g_hash_table_iter_init(&iter, sphb->msi);
|
|
|
|
for (i = 0; g_hash_table_iter_next(&iter, &key, &value); ++i) {
|
|
|
|
sphb->msi_devs[i].key = *(uint32_t *) key;
|
|
|
|
sphb->msi_devs[i].value = *(spapr_pci_msi *) value;
|
|
|
|
}
|
2016-11-23 02:26:38 +03:00
|
|
|
|
|
|
|
if (sphb->pre_2_8_migration) {
|
|
|
|
sphb->mig_liobn = sphb->dma_liobn[0];
|
|
|
|
sphb->mig_mem_win_addr = sphb->mem_win_addr;
|
|
|
|
sphb->mig_mem_win_size = sphb->mem_win_size;
|
|
|
|
sphb->mig_io_win_addr = sphb->io_win_addr;
|
|
|
|
sphb->mig_io_win_size = sphb->io_win_size;
|
|
|
|
|
|
|
|
if ((sphb->mem64_win_size != 0)
|
|
|
|
&& (sphb->mem64_win_addr
|
|
|
|
== (sphb->mem_win_addr + sphb->mem_win_size))) {
|
|
|
|
sphb->mig_mem_win_size += sphb->mem64_win_size;
|
|
|
|
}
|
|
|
|
}
|
2014-05-30 13:34:20 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int spapr_pci_post_load(void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = opaque;
|
|
|
|
gpointer key, value;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < sphb->msi_devs_num; ++i) {
|
|
|
|
key = g_memdup(&sphb->msi_devs[i].key,
|
|
|
|
sizeof(sphb->msi_devs[i].key));
|
|
|
|
value = g_memdup(&sphb->msi_devs[i].value,
|
|
|
|
sizeof(sphb->msi_devs[i].value));
|
|
|
|
g_hash_table_insert(sphb->msi, key, value);
|
|
|
|
}
|
2015-08-26 15:02:53 +03:00
|
|
|
g_free(sphb->msi_devs);
|
|
|
|
sphb->msi_devs = NULL;
|
2014-05-30 13:34:20 +04:00
|
|
|
sphb->msi_devs_num = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-23 02:26:38 +03:00
|
|
|
static bool pre_2_8_migration(void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = opaque;
|
|
|
|
|
|
|
|
return sphb->pre_2_8_migration;
|
|
|
|
}
|
|
|
|
|
2013-07-18 23:33:02 +04:00
|
|
|
static const VMStateDescription vmstate_spapr_pci = {
|
|
|
|
.name = "spapr_pci",
|
2016-11-21 04:12:10 +03:00
|
|
|
.version_id = 2,
|
2014-05-30 13:34:20 +04:00
|
|
|
.minimum_version_id = 2,
|
|
|
|
.pre_save = spapr_pci_pre_save,
|
|
|
|
.post_load = spapr_pci_post_load,
|
2014-04-16 17:24:04 +04:00
|
|
|
.fields = (VMStateField[]) {
|
2013-07-18 23:33:02 +04:00
|
|
|
VMSTATE_UINT64_EQUAL(buid, sPAPRPHBState),
|
2016-11-23 02:26:38 +03:00
|
|
|
VMSTATE_UINT32_TEST(mig_liobn, sPAPRPHBState, pre_2_8_migration),
|
|
|
|
VMSTATE_UINT64_TEST(mig_mem_win_addr, sPAPRPHBState, pre_2_8_migration),
|
|
|
|
VMSTATE_UINT64_TEST(mig_mem_win_size, sPAPRPHBState, pre_2_8_migration),
|
|
|
|
VMSTATE_UINT64_TEST(mig_io_win_addr, sPAPRPHBState, pre_2_8_migration),
|
|
|
|
VMSTATE_UINT64_TEST(mig_io_win_size, sPAPRPHBState, pre_2_8_migration),
|
2013-07-18 23:33:02 +04:00
|
|
|
VMSTATE_STRUCT_ARRAY(lsi_table, sPAPRPHBState, PCI_NUM_PINS, 0,
|
|
|
|
vmstate_spapr_pci_lsi, struct spapr_pci_lsi),
|
2014-05-30 13:34:20 +04:00
|
|
|
VMSTATE_INT32(msi_devs_num, sPAPRPHBState),
|
|
|
|
VMSTATE_STRUCT_VARRAY_ALLOC(msi_devs, sPAPRPHBState, msi_devs_num, 0,
|
|
|
|
vmstate_spapr_pci_msi, spapr_pci_msi_mig),
|
2013-07-18 23:33:02 +04:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-06-06 12:48:49 +04:00
|
|
|
static const char *spapr_phb_root_bus_path(PCIHostState *host_bridge,
|
|
|
|
PCIBus *rootbus)
|
|
|
|
{
|
|
|
|
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(host_bridge);
|
|
|
|
|
|
|
|
return sphb->dtbusname;
|
|
|
|
}
|
|
|
|
|
2012-03-12 21:50:24 +04:00
|
|
|
static void spapr_phb_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2013-06-06 12:48:49 +04:00
|
|
|
PCIHostBridgeClass *hc = PCI_HOST_BRIDGE_CLASS(klass);
|
2012-03-12 21:50:24 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2015-05-07 08:33:55 +03:00
|
|
|
HotplugHandlerClass *hp = HOTPLUG_HANDLER_CLASS(klass);
|
2012-03-12 21:50:24 +04:00
|
|
|
|
2013-06-06 12:48:49 +04:00
|
|
|
hc->root_bus_path = spapr_phb_root_bus_path;
|
2013-11-21 08:08:55 +04:00
|
|
|
dc->realize = spapr_phb_realize;
|
2012-03-12 21:50:24 +04:00
|
|
|
dc->props = spapr_phb_properties;
|
2012-09-12 20:57:14 +04:00
|
|
|
dc->reset = spapr_phb_reset;
|
2013-07-18 23:33:02 +04:00
|
|
|
dc->vmsd = &vmstate_spapr_pci;
|
2014-01-13 13:29:09 +04:00
|
|
|
set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
|
2015-05-07 08:33:55 +03:00
|
|
|
hp->plug = spapr_phb_hot_plug_child;
|
|
|
|
hp->unplug = spapr_phb_hot_unplug_child;
|
2012-03-12 21:50:24 +04:00
|
|
|
}
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2012-08-20 21:07:56 +04:00
|
|
|
static const TypeInfo spapr_phb_info = {
|
2012-08-20 21:08:05 +04:00
|
|
|
.name = TYPE_SPAPR_PCI_HOST_BRIDGE,
|
2012-08-20 21:08:08 +04:00
|
|
|
.parent = TYPE_PCI_HOST_BRIDGE,
|
2012-03-12 21:50:24 +04:00
|
|
|
.instance_size = sizeof(sPAPRPHBState),
|
|
|
|
.class_init = spapr_phb_class_init,
|
2015-05-07 08:33:55 +03:00
|
|
|
.interfaces = (InterfaceInfo[]) {
|
|
|
|
{ TYPE_HOTPLUG_HANDLER },
|
|
|
|
{ }
|
|
|
|
}
|
2012-03-12 21:50:24 +04:00
|
|
|
};
|
|
|
|
|
2015-07-02 09:23:04 +03:00
|
|
|
PCIHostState *spapr_create_phb(sPAPRMachineState *spapr, int index)
|
2012-03-12 21:50:24 +04:00
|
|
|
{
|
|
|
|
DeviceState *dev;
|
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
dev = qdev_create(NULL, TYPE_SPAPR_PCI_HOST_BRIDGE);
|
2013-01-23 21:20:39 +04:00
|
|
|
qdev_prop_set_uint32(dev, "index", index);
|
2012-03-12 21:50:24 +04:00
|
|
|
qdev_init_nofail(dev);
|
2013-01-23 21:20:39 +04:00
|
|
|
|
|
|
|
return PCI_HOST_BRIDGE(dev);
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
|
2015-07-02 09:23:21 +03:00
|
|
|
typedef struct sPAPRFDT {
|
|
|
|
void *fdt;
|
|
|
|
int node_off;
|
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
} sPAPRFDT;
|
|
|
|
|
|
|
|
static void spapr_populate_pci_devices_dt(PCIBus *bus, PCIDevice *pdev,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
PCIBus *sec_bus;
|
|
|
|
sPAPRFDT *p = opaque;
|
|
|
|
int offset;
|
|
|
|
sPAPRFDT s_fdt;
|
|
|
|
|
2015-07-02 09:23:23 +03:00
|
|
|
offset = spapr_create_pci_child_dt(p->sphb, pdev, p->fdt, p->node_off);
|
2015-07-02 09:23:21 +03:00
|
|
|
if (!offset) {
|
|
|
|
error_report("Failed to create pci child device tree node");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((pci_default_read_config(pdev, PCI_HEADER_TYPE, 1) !=
|
|
|
|
PCI_HEADER_TYPE_BRIDGE)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sec_bus = pci_bridge_get_sec_bus(PCI_BRIDGE(pdev));
|
|
|
|
if (!sec_bus) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
s_fdt.fdt = p->fdt;
|
|
|
|
s_fdt.node_off = offset;
|
|
|
|
s_fdt.sphb = p->sphb;
|
|
|
|
pci_for_each_device(sec_bus, pci_bus_num(sec_bus),
|
|
|
|
spapr_populate_pci_devices_dt,
|
|
|
|
&s_fdt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_pci_enumerate_bridge(PCIBus *bus, PCIDevice *pdev,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
unsigned int *bus_no = opaque;
|
|
|
|
unsigned int primary = *bus_no;
|
|
|
|
unsigned int subordinate = 0xff;
|
|
|
|
PCIBus *sec_bus = NULL;
|
|
|
|
|
|
|
|
if ((pci_default_read_config(pdev, PCI_HEADER_TYPE, 1) !=
|
|
|
|
PCI_HEADER_TYPE_BRIDGE)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
(*bus_no)++;
|
|
|
|
pci_default_write_config(pdev, PCI_PRIMARY_BUS, primary, 1);
|
|
|
|
pci_default_write_config(pdev, PCI_SECONDARY_BUS, *bus_no, 1);
|
|
|
|
pci_default_write_config(pdev, PCI_SUBORDINATE_BUS, *bus_no, 1);
|
|
|
|
|
|
|
|
sec_bus = pci_bridge_get_sec_bus(PCI_BRIDGE(pdev));
|
|
|
|
if (!sec_bus) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_default_write_config(pdev, PCI_SUBORDINATE_BUS, subordinate, 1);
|
|
|
|
pci_for_each_device(sec_bus, pci_bus_num(sec_bus),
|
|
|
|
spapr_phb_pci_enumerate_bridge, bus_no);
|
|
|
|
pci_default_write_config(pdev, PCI_SUBORDINATE_BUS, *bus_no, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spapr_phb_pci_enumerate(sPAPRPHBState *phb)
|
|
|
|
{
|
|
|
|
PCIBus *bus = PCI_HOST_BRIDGE(phb)->bus;
|
|
|
|
unsigned int bus_no = 0;
|
|
|
|
|
|
|
|
pci_for_each_device(bus, pci_bus_num(bus),
|
|
|
|
spapr_phb_pci_enumerate_bridge,
|
|
|
|
&bus_no);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-06-13 22:40:06 +04:00
|
|
|
int spapr_populate_pci_dt(sPAPRPHBState *phb,
|
|
|
|
uint32_t xics_phandle,
|
|
|
|
void *fdt)
|
2011-10-30 21:16:46 +04:00
|
|
|
{
|
2015-05-07 08:33:53 +03:00
|
|
|
int bus_off, i, j, ret;
|
2015-07-02 09:23:10 +03:00
|
|
|
char nodename[FDT_NAME_MAX];
|
2011-10-30 21:16:46 +04:00
|
|
|
uint32_t bus_range[] = { cpu_to_be32(0), cpu_to_be32(0xff) };
|
|
|
|
struct {
|
|
|
|
uint32_t hi;
|
|
|
|
uint64_t child;
|
|
|
|
uint64_t parent;
|
|
|
|
uint64_t size;
|
2012-07-18 12:22:51 +04:00
|
|
|
} QEMU_PACKED ranges[] = {
|
2011-10-30 21:16:46 +04:00
|
|
|
{
|
|
|
|
cpu_to_be32(b_ss(1)), cpu_to_be64(0),
|
|
|
|
cpu_to_be64(phb->io_win_addr),
|
|
|
|
cpu_to_be64(memory_region_size(&phb->iospace)),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
cpu_to_be32(b_ss(2)), cpu_to_be64(SPAPR_PCI_MEM_WIN_BUS_OFFSET),
|
|
|
|
cpu_to_be64(phb->mem_win_addr),
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
cpu_to_be64(phb->mem_win_size),
|
2015-01-30 04:53:19 +03:00
|
|
|
},
|
|
|
|
{
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
cpu_to_be32(b_ss(3)), cpu_to_be64(phb->mem64_win_pciaddr),
|
|
|
|
cpu_to_be64(phb->mem64_win_addr),
|
|
|
|
cpu_to_be64(phb->mem64_win_size),
|
2011-10-30 21:16:46 +04:00
|
|
|
},
|
|
|
|
};
|
spapr_pci: Add a 64-bit MMIO window
On real hardware, and under pHyp, the PCI host bridges on Power machines
typically advertise two outbound MMIO windows from the guest's physical
memory space to PCI memory space:
- A 32-bit window which maps onto 2GiB..4GiB in the PCI address space
- A 64-bit window which maps onto a large region somewhere high in PCI
address space (traditionally this used an identity mapping from guest
physical address to PCI address, but that's not always the case)
The qemu implementation in spapr-pci-host-bridge, however, only supports a
single outbound MMIO window, however. At least some Linux versions expect
the two windows however, so we arranged this window to map onto the PCI
memory space from 2 GiB..~64 GiB, then advertised it as two contiguous
windows, the "32-bit" window from 2G..4G and the "64-bit" window from
4G..~64G.
This approach means, however, that the 64G window is not naturally aligned.
In turn this limits the size of the largest BAR we can map (which does have
to be naturally aligned) to roughly half of the total window. With some
large nVidia GPGPU cards which have huge memory BARs, this is starting to
be a problem.
This patch adds true support for separate 32-bit and 64-bit outbound MMIO
windows to the spapr-pci-host-bridge implementation, each of which can
be independently configured. The 32-bit window always maps to 2G.. in PCI
space, but the PCI address of the 64-bit window can be configured (it
defaults to the same as the guest physical address).
So as not to break possible existing configurations, as long as a 64-bit
window is not specified, a large single window can be specified. This
will appear the same way to the guest as the old approach, although it's
now implemented by two contiguous memory regions rather than a single one.
For now, this only adds the possibility of 64-bit windows. The default
configuration still uses the legacy mode.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Laurent Vivier <lvivier@redhat.com>
2016-10-11 06:23:33 +03:00
|
|
|
const unsigned sizeof_ranges =
|
|
|
|
(phb->mem64_win_size ? 3 : 2) * sizeof(ranges[0]);
|
2011-10-30 21:16:46 +04:00
|
|
|
uint64_t bus_reg[] = { cpu_to_be64(phb->buid), 0 };
|
|
|
|
uint32_t interrupt_map_mask[] = {
|
2012-04-25 21:55:42 +04:00
|
|
|
cpu_to_be32(b_ddddd(-1)|b_fff(0)), 0x0, 0x0, cpu_to_be32(-1)};
|
|
|
|
uint32_t interrupt_map[PCI_SLOT_MAX * PCI_NUM_PINS][7];
|
2016-07-04 06:33:07 +03:00
|
|
|
uint32_t ddw_applicable[] = {
|
|
|
|
cpu_to_be32(RTAS_IBM_QUERY_PE_DMA_WINDOW),
|
|
|
|
cpu_to_be32(RTAS_IBM_CREATE_PE_DMA_WINDOW),
|
|
|
|
cpu_to_be32(RTAS_IBM_REMOVE_PE_DMA_WINDOW)
|
|
|
|
};
|
|
|
|
uint32_t ddw_extensions[] = {
|
|
|
|
cpu_to_be32(1),
|
|
|
|
cpu_to_be32(RTAS_IBM_RESET_PE_DMA_WINDOW)
|
|
|
|
};
|
2016-07-27 11:03:38 +03:00
|
|
|
uint32_t associativity[] = {cpu_to_be32(0x4),
|
|
|
|
cpu_to_be32(0x0),
|
|
|
|
cpu_to_be32(0x0),
|
|
|
|
cpu_to_be32(0x0),
|
|
|
|
cpu_to_be32(phb->numa_node)};
|
2015-05-07 08:33:36 +03:00
|
|
|
sPAPRTCETable *tcet;
|
2015-07-02 09:23:21 +03:00
|
|
|
PCIBus *bus = PCI_HOST_BRIDGE(phb)->bus;
|
|
|
|
sPAPRFDT s_fdt;
|
2011-10-30 21:16:46 +04:00
|
|
|
|
|
|
|
/* Start populating the FDT */
|
2015-07-02 09:23:10 +03:00
|
|
|
snprintf(nodename, FDT_NAME_MAX, "pci@%" PRIx64, phb->buid);
|
2011-10-30 21:16:46 +04:00
|
|
|
bus_off = fdt_add_subnode(fdt, 0, nodename);
|
|
|
|
if (bus_off < 0) {
|
|
|
|
return bus_off;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write PHB properties */
|
|
|
|
_FDT(fdt_setprop_string(fdt, bus_off, "device_type", "pci"));
|
|
|
|
_FDT(fdt_setprop_string(fdt, bus_off, "compatible", "IBM,Logical_PHB"));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "#address-cells", 0x3));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "#size-cells", 0x2));
|
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "#interrupt-cells", 0x1));
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "used-by-rtas", NULL, 0));
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "bus-range", &bus_range, sizeof(bus_range)));
|
2015-01-30 04:53:19 +03:00
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "ranges", &ranges, sizeof_ranges));
|
2011-10-30 21:16:46 +04:00
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "reg", &bus_reg, sizeof(bus_reg)));
|
2012-01-11 23:46:25 +04:00
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pci-config-space-type", 0x1));
|
2016-06-28 22:05:12 +03:00
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pe-total-#msi", XICS_IRQS_SPAPR));
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
/* Dynamic DMA window */
|
|
|
|
if (phb->ddw_enabled) {
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "ibm,ddw-applicable", &ddw_applicable,
|
|
|
|
sizeof(ddw_applicable)));
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "ibm,ddw-extensions",
|
|
|
|
&ddw_extensions, sizeof(ddw_extensions)));
|
|
|
|
}
|
|
|
|
|
2016-07-27 11:03:38 +03:00
|
|
|
/* Advertise NUMA via ibm,associativity */
|
2016-10-18 23:50:23 +03:00
|
|
|
if (phb->numa_node != -1) {
|
2016-07-27 11:03:38 +03:00
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "ibm,associativity", associativity,
|
|
|
|
sizeof(associativity)));
|
|
|
|
}
|
|
|
|
|
2012-01-11 23:46:28 +04:00
|
|
|
/* Build the interrupt-map, this must matches what is done
|
|
|
|
* in pci_spapr_map_irq
|
|
|
|
*/
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "interrupt-map-mask",
|
|
|
|
&interrupt_map_mask, sizeof(interrupt_map_mask)));
|
2012-04-25 21:55:42 +04:00
|
|
|
for (i = 0; i < PCI_SLOT_MAX; i++) {
|
|
|
|
for (j = 0; j < PCI_NUM_PINS; j++) {
|
|
|
|
uint32_t *irqmap = interrupt_map[i*PCI_NUM_PINS + j];
|
|
|
|
int lsi_num = pci_spapr_swizzle(i, j);
|
|
|
|
|
|
|
|
irqmap[0] = cpu_to_be32(b_ddddd(i)|b_fff(0));
|
|
|
|
irqmap[1] = 0;
|
|
|
|
irqmap[2] = 0;
|
|
|
|
irqmap[3] = cpu_to_be32(j+1);
|
|
|
|
irqmap[4] = cpu_to_be32(xics_phandle);
|
2012-08-07 20:10:32 +04:00
|
|
|
irqmap[5] = cpu_to_be32(phb->lsi_table[lsi_num].irq);
|
2012-04-25 21:55:42 +04:00
|
|
|
irqmap[6] = cpu_to_be32(0x8);
|
|
|
|
}
|
2011-10-30 21:16:46 +04:00
|
|
|
}
|
|
|
|
/* Write interrupt map */
|
|
|
|
_FDT(fdt_setprop(fdt, bus_off, "interrupt-map", &interrupt_map,
|
2012-04-25 21:55:42 +04:00
|
|
|
sizeof(interrupt_map)));
|
2011-10-30 21:16:46 +04:00
|
|
|
|
2016-07-04 06:33:07 +03:00
|
|
|
tcet = spapr_tce_find_by_liobn(phb->dma_liobn[0]);
|
2016-04-21 13:08:58 +03:00
|
|
|
if (!tcet) {
|
|
|
|
return -1;
|
|
|
|
}
|
2015-05-07 08:33:36 +03:00
|
|
|
spapr_dma_dt(fdt, bus_off, "ibm,dma-window",
|
|
|
|
tcet->liobn, tcet->bus_offset,
|
|
|
|
tcet->nb_table << tcet->page_shift);
|
2012-06-27 08:50:46 +04:00
|
|
|
|
2015-07-02 09:23:21 +03:00
|
|
|
/* Walk the bridges and program the bus numbers*/
|
|
|
|
spapr_phb_pci_enumerate(phb);
|
|
|
|
_FDT(fdt_setprop_cell(fdt, bus_off, "qemu,phb-enumerated", 0x1));
|
|
|
|
|
|
|
|
/* Populate tree nodes with PCI devices attached */
|
|
|
|
s_fdt.fdt = fdt;
|
|
|
|
s_fdt.node_off = bus_off;
|
|
|
|
s_fdt.sphb = phb;
|
|
|
|
pci_for_each_device(bus, pci_bus_num(bus),
|
|
|
|
spapr_populate_pci_devices_dt,
|
|
|
|
&s_fdt);
|
|
|
|
|
2015-05-07 08:33:53 +03:00
|
|
|
ret = spapr_drc_populate_dt(fdt, bus_off, OBJECT(phb),
|
|
|
|
SPAPR_DR_CONNECTOR_TYPE_PCI);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-30 21:16:46 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2012-03-12 21:50:24 +04:00
|
|
|
|
2012-08-07 20:10:33 +04:00
|
|
|
void spapr_pci_rtas_init(void)
|
|
|
|
{
|
2014-06-23 17:26:32 +04:00
|
|
|
spapr_rtas_register(RTAS_READ_PCI_CONFIG, "read-pci-config",
|
|
|
|
rtas_read_pci_config);
|
|
|
|
spapr_rtas_register(RTAS_WRITE_PCI_CONFIG, "write-pci-config",
|
|
|
|
rtas_write_pci_config);
|
|
|
|
spapr_rtas_register(RTAS_IBM_READ_PCI_CONFIG, "ibm,read-pci-config",
|
|
|
|
rtas_ibm_read_pci_config);
|
|
|
|
spapr_rtas_register(RTAS_IBM_WRITE_PCI_CONFIG, "ibm,write-pci-config",
|
|
|
|
rtas_ibm_write_pci_config);
|
2016-03-04 12:24:28 +03:00
|
|
|
if (msi_nonbroken) {
|
2014-06-23 17:26:32 +04:00
|
|
|
spapr_rtas_register(RTAS_IBM_QUERY_INTERRUPT_SOURCE_NUMBER,
|
|
|
|
"ibm,query-interrupt-source-number",
|
2012-08-07 20:10:37 +04:00
|
|
|
rtas_ibm_query_interrupt_source_number);
|
2014-06-23 17:26:32 +04:00
|
|
|
spapr_rtas_register(RTAS_IBM_CHANGE_MSI, "ibm,change-msi",
|
|
|
|
rtas_ibm_change_msi);
|
2012-08-07 20:10:37 +04:00
|
|
|
}
|
2015-02-20 07:58:52 +03:00
|
|
|
|
|
|
|
spapr_rtas_register(RTAS_IBM_SET_EEH_OPTION,
|
|
|
|
"ibm,set-eeh-option",
|
|
|
|
rtas_ibm_set_eeh_option);
|
|
|
|
spapr_rtas_register(RTAS_IBM_GET_CONFIG_ADDR_INFO2,
|
|
|
|
"ibm,get-config-addr-info2",
|
|
|
|
rtas_ibm_get_config_addr_info2);
|
|
|
|
spapr_rtas_register(RTAS_IBM_READ_SLOT_RESET_STATE2,
|
|
|
|
"ibm,read-slot-reset-state2",
|
|
|
|
rtas_ibm_read_slot_reset_state2);
|
|
|
|
spapr_rtas_register(RTAS_IBM_SET_SLOT_RESET,
|
|
|
|
"ibm,set-slot-reset",
|
|
|
|
rtas_ibm_set_slot_reset);
|
|
|
|
spapr_rtas_register(RTAS_IBM_CONFIGURE_PE,
|
|
|
|
"ibm,configure-pe",
|
|
|
|
rtas_ibm_configure_pe);
|
|
|
|
spapr_rtas_register(RTAS_IBM_SLOT_ERROR_DETAIL,
|
|
|
|
"ibm,slot-error-detail",
|
|
|
|
rtas_ibm_slot_error_detail);
|
2012-08-07 20:10:33 +04:00
|
|
|
}
|
|
|
|
|
2012-08-20 21:08:05 +04:00
|
|
|
static void spapr_pci_register_types(void)
|
2012-03-12 21:50:24 +04:00
|
|
|
{
|
|
|
|
type_register_static(&spapr_phb_info);
|
|
|
|
}
|
2012-08-20 21:08:05 +04:00
|
|
|
|
|
|
|
type_init(spapr_pci_register_types)
|
2015-02-10 07:36:16 +03:00
|
|
|
|
|
|
|
static int spapr_switch_one_vga(DeviceState *dev, void *opaque)
|
|
|
|
{
|
|
|
|
bool be = *(bool *)opaque;
|
|
|
|
|
|
|
|
if (object_dynamic_cast(OBJECT(dev), "VGA")
|
|
|
|
|| object_dynamic_cast(OBJECT(dev), "secondary-vga")) {
|
|
|
|
object_property_set_bool(OBJECT(dev), be, "big-endian-framebuffer",
|
|
|
|
&error_abort);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void spapr_pci_switch_vga(bool big_endian)
|
|
|
|
{
|
2015-07-02 09:23:04 +03:00
|
|
|
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
|
2015-02-10 07:36:16 +03:00
|
|
|
sPAPRPHBState *sphb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For backward compatibility with existing guests, we switch
|
|
|
|
* the endianness of the VGA controller when changing the guest
|
|
|
|
* interrupt mode
|
|
|
|
*/
|
|
|
|
QLIST_FOREACH(sphb, &spapr->phbs, list) {
|
|
|
|
BusState *bus = &PCI_HOST_BRIDGE(sphb)->bus->qbus;
|
|
|
|
qbus_walk_children(bus, spapr_switch_one_vga, NULL, NULL, NULL,
|
|
|
|
&big_endian);
|
|
|
|
}
|
|
|
|
}
|