2010-10-19 11:06:34 +02:00
|
|
|
|
/*
|
|
|
|
|
* pcie.c
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2010 Isaku Yamahata <yamahata at valinux co jp>
|
|
|
|
|
* VA Linux Systems Japan K.K.
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
|
* with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-01-26 19:17:15 +01: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 09:01:28 +01:00
|
|
|
|
#include "qapi/error.h"
|
2012-12-12 22:05:42 +01:00
|
|
|
|
#include "hw/pci/pci_bridge.h"
|
|
|
|
|
#include "hw/pci/pcie.h"
|
|
|
|
|
#include "hw/pci/msix.h"
|
|
|
|
|
#include "hw/pci/msi.h"
|
2012-12-12 14:00:45 +01:00
|
|
|
|
#include "hw/pci/pci_bus.h"
|
2012-12-12 22:05:42 +01:00
|
|
|
|
#include "hw/pci/pcie_regs.h"
|
2018-12-12 20:39:31 +01:00
|
|
|
|
#include "hw/pci/pcie_port.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
|
#include "qemu/range.h"
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
|
|
|
|
//#define DEBUG_PCIE
|
|
|
|
|
#ifdef DEBUG_PCIE
|
|
|
|
|
# define PCIE_DPRINTF(fmt, ...) \
|
|
|
|
|
fprintf(stderr, "%s:%d " fmt, __func__, __LINE__, ## __VA_ARGS__)
|
|
|
|
|
#else
|
|
|
|
|
# define PCIE_DPRINTF(fmt, ...) do {} while (0)
|
|
|
|
|
#endif
|
|
|
|
|
#define PCIE_DEV_PRINTF(dev, fmt, ...) \
|
|
|
|
|
PCIE_DPRINTF("%s:%x "fmt, (dev)->name, (dev)->devfn, ## __VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
* pci express capability helper functions
|
|
|
|
|
*/
|
|
|
|
|
|
2016-06-01 10:23:33 +02:00
|
|
|
|
static void
|
2016-07-19 22:16:19 +02:00
|
|
|
|
pcie_cap_v1_fill(PCIDevice *dev, uint8_t port, uint8_t type, uint8_t version)
|
2016-06-01 10:23:33 +02:00
|
|
|
|
{
|
2016-07-19 22:16:19 +02:00
|
|
|
|
uint8_t *exp_cap = dev->config + dev->exp.exp_cap;
|
|
|
|
|
uint8_t *cmask = dev->cmask + dev->exp.exp_cap;
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
/* capability register
|
2016-06-01 10:23:33 +02:00
|
|
|
|
interrupt message number defaults to 0 */
|
2010-10-19 11:06:34 +02:00
|
|
|
|
pci_set_word(exp_cap + PCI_EXP_FLAGS,
|
|
|
|
|
((type << PCI_EXP_FLAGS_TYPE_SHIFT) & PCI_EXP_FLAGS_TYPE) |
|
2016-06-01 10:23:33 +02:00
|
|
|
|
version);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
|
|
|
|
/* device capability register
|
|
|
|
|
* table 7-12:
|
|
|
|
|
* roll based error reporting bit must be set by all
|
|
|
|
|
* Functions conforming to the ECN, PCI Express Base
|
|
|
|
|
* Specification, Revision 1.1., or subsequent PCI Express Base
|
|
|
|
|
* Specification revisions.
|
|
|
|
|
*/
|
|
|
|
|
pci_set_long(exp_cap + PCI_EXP_DEVCAP, PCI_EXP_DEVCAP_RBER);
|
|
|
|
|
|
|
|
|
|
pci_set_long(exp_cap + PCI_EXP_LNKCAP,
|
|
|
|
|
(port << PCI_EXP_LNKCAP_PN_SHIFT) |
|
|
|
|
|
PCI_EXP_LNKCAP_ASPMS_0S |
|
2018-12-12 20:38:41 +01:00
|
|
|
|
QEMU_PCI_EXP_LNKCAP_MLW(QEMU_PCI_EXP_LNK_X1) |
|
|
|
|
|
QEMU_PCI_EXP_LNKCAP_MLS(QEMU_PCI_EXP_LNK_2_5GT));
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
|
|
|
|
pci_set_word(exp_cap + PCI_EXP_LNKSTA,
|
2018-12-12 20:38:41 +01:00
|
|
|
|
QEMU_PCI_EXP_LNKSTA_NLW(QEMU_PCI_EXP_LNK_X1) |
|
|
|
|
|
QEMU_PCI_EXP_LNKSTA_CLS(QEMU_PCI_EXP_LNK_2_5GT));
|
2016-07-19 22:16:19 +02:00
|
|
|
|
|
|
|
|
|
if (dev->cap_present & QEMU_PCIE_LNKSTA_DLLLA) {
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_DLLLA);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We changed link status bits over time, and changing them across
|
|
|
|
|
* migrations is generally fine as hardware changes them too.
|
|
|
|
|
* Let's not bother checking.
|
|
|
|
|
*/
|
|
|
|
|
pci_set_word(cmask + PCI_EXP_LNKSTA, 0);
|
2016-06-01 10:23:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 20:39:31 +01:00
|
|
|
|
static void pcie_cap_fill_slot_lnk(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
PCIESlot *s = (PCIESlot *)object_dynamic_cast(OBJECT(dev), TYPE_PCIE_SLOT);
|
|
|
|
|
uint8_t *exp_cap = dev->config + dev->exp.exp_cap;
|
|
|
|
|
|
|
|
|
|
/* Skip anything that isn't a PCIESlot */
|
|
|
|
|
if (!s) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Clear and fill LNKCAP from what was configured above */
|
|
|
|
|
pci_long_test_and_clear_mask(exp_cap + PCI_EXP_LNKCAP,
|
|
|
|
|
PCI_EXP_LNKCAP_MLW | PCI_EXP_LNKCAP_SLS);
|
|
|
|
|
pci_long_test_and_set_mask(exp_cap + PCI_EXP_LNKCAP,
|
|
|
|
|
QEMU_PCI_EXP_LNKCAP_MLW(s->width) |
|
|
|
|
|
QEMU_PCI_EXP_LNKCAP_MLS(s->speed));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Link bandwidth notification is required for all root ports and
|
|
|
|
|
* downstream ports supporting links wider than x1 or multiple link
|
|
|
|
|
* speeds.
|
|
|
|
|
*/
|
|
|
|
|
if (s->width > QEMU_PCI_EXP_LNK_X1 ||
|
|
|
|
|
s->speed > QEMU_PCI_EXP_LNK_2_5GT) {
|
|
|
|
|
pci_long_test_and_set_mask(exp_cap + PCI_EXP_LNKCAP,
|
|
|
|
|
PCI_EXP_LNKCAP_LBNC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (s->speed > QEMU_PCI_EXP_LNK_2_5GT) {
|
|
|
|
|
/*
|
|
|
|
|
* Hot-plug capable downstream ports and downstream ports supporting
|
|
|
|
|
* link speeds greater than 5GT/s must hardwire PCI_EXP_LNKCAP_DLLLARC
|
|
|
|
|
* to 1b. PCI_EXP_LNKCAP_DLLLARC implies PCI_EXP_LNKSTA_DLLLA, which
|
|
|
|
|
* we also hardwire to 1b here. 2.5GT/s hot-plug slots should also
|
|
|
|
|
* technically implement this, but it's not done here for compatibility.
|
|
|
|
|
*/
|
|
|
|
|
pci_long_test_and_set_mask(exp_cap + PCI_EXP_LNKCAP,
|
|
|
|
|
PCI_EXP_LNKCAP_DLLLARC);
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_DLLLA);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Target Link Speed defaults to the highest link speed supported by
|
|
|
|
|
* the component. 2.5GT/s devices are permitted to hardwire to zero.
|
|
|
|
|
*/
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_LNKCTL2,
|
|
|
|
|
PCI_EXP_LNKCTL2_TLS);
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKCTL2,
|
|
|
|
|
QEMU_PCI_EXP_LNKCAP_MLS(s->speed) &
|
|
|
|
|
PCI_EXP_LNKCTL2_TLS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 2.5 & 5.0GT/s can be fully described by LNKCAP, but 8.0GT/s is
|
|
|
|
|
* actually a reference to the highest bit supported in this register.
|
|
|
|
|
* We assume the device supports all link speeds.
|
|
|
|
|
*/
|
|
|
|
|
if (s->speed > QEMU_PCI_EXP_LNK_5GT) {
|
|
|
|
|
pci_long_test_and_clear_mask(exp_cap + PCI_EXP_LNKCAP2, ~0U);
|
|
|
|
|
pci_long_test_and_set_mask(exp_cap + PCI_EXP_LNKCAP2,
|
|
|
|
|
PCI_EXP_LNKCAP2_SLS_2_5GB |
|
|
|
|
|
PCI_EXP_LNKCAP2_SLS_5_0GB |
|
|
|
|
|
PCI_EXP_LNKCAP2_SLS_8_0GB);
|
|
|
|
|
if (s->speed > QEMU_PCI_EXP_LNK_8GT) {
|
|
|
|
|
pci_long_test_and_set_mask(exp_cap + PCI_EXP_LNKCAP2,
|
|
|
|
|
PCI_EXP_LNKCAP2_SLS_16_0GB);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-27 08:16:52 +02:00
|
|
|
|
int pcie_cap_init(PCIDevice *dev, uint8_t offset,
|
|
|
|
|
uint8_t type, uint8_t port,
|
|
|
|
|
Error **errp)
|
2016-06-01 10:23:33 +02:00
|
|
|
|
{
|
|
|
|
|
/* PCIe cap v2 init */
|
|
|
|
|
int pos;
|
|
|
|
|
uint8_t *exp_cap;
|
|
|
|
|
|
|
|
|
|
assert(pci_is_express(dev));
|
|
|
|
|
|
2017-06-27 08:16:50 +02:00
|
|
|
|
pos = pci_add_capability(dev, PCI_CAP_ID_EXP, offset,
|
2017-06-27 08:16:52 +02:00
|
|
|
|
PCI_EXP_VER2_SIZEOF, errp);
|
2016-06-01 10:23:33 +02:00
|
|
|
|
if (pos < 0) {
|
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
dev->exp.exp_cap = pos;
|
|
|
|
|
exp_cap = dev->config + pos;
|
|
|
|
|
|
|
|
|
|
/* Filling values common with v1 */
|
2016-07-19 22:16:19 +02:00
|
|
|
|
pcie_cap_v1_fill(dev, port, type, PCI_EXP_FLAGS_VER2);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
2018-12-12 20:39:31 +01:00
|
|
|
|
/* Fill link speed and width options */
|
|
|
|
|
pcie_cap_fill_slot_lnk(dev);
|
|
|
|
|
|
2016-06-01 10:23:33 +02:00
|
|
|
|
/* Filling v2 specific values */
|
2010-10-19 11:06:34 +02:00
|
|
|
|
pci_set_long(exp_cap + PCI_EXP_DEVCAP2,
|
|
|
|
|
PCI_EXP_DEVCAP2_EFF | PCI_EXP_DEVCAP2_EETLPP);
|
|
|
|
|
|
2015-03-13 04:18:03 +01:00
|
|
|
|
pci_set_word(dev->wmask + pos + PCI_EXP_DEVCTL2, PCI_EXP_DEVCTL2_EETLPPB);
|
2017-02-20 21:43:10 +01:00
|
|
|
|
|
|
|
|
|
if (dev->cap_present & QEMU_PCIE_EXTCAP_INIT) {
|
|
|
|
|
/* read-only to behave like a 'NULL' Extended Capability Header */
|
|
|
|
|
pci_set_long(dev->wmask + PCI_CONFIG_SPACE_SIZE, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-01 10:23:33 +02:00
|
|
|
|
int pcie_cap_v1_init(PCIDevice *dev, uint8_t offset, uint8_t type,
|
|
|
|
|
uint8_t port)
|
|
|
|
|
{
|
|
|
|
|
/* PCIe cap v1 init */
|
|
|
|
|
int pos;
|
2017-06-27 08:16:50 +02:00
|
|
|
|
Error *local_err = NULL;
|
2016-06-01 10:23:33 +02:00
|
|
|
|
|
|
|
|
|
assert(pci_is_express(dev));
|
|
|
|
|
|
2017-06-27 08:16:50 +02:00
|
|
|
|
pos = pci_add_capability(dev, PCI_CAP_ID_EXP, offset,
|
|
|
|
|
PCI_EXP_VER1_SIZEOF, &local_err);
|
2016-06-01 10:23:33 +02:00
|
|
|
|
if (pos < 0) {
|
2017-06-27 08:16:50 +02:00
|
|
|
|
error_report_err(local_err);
|
2016-06-01 10:23:33 +02:00
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
dev->exp.exp_cap = pos;
|
|
|
|
|
|
2016-07-19 22:16:19 +02:00
|
|
|
|
pcie_cap_v1_fill(dev, port, type, PCI_EXP_FLAGS_VER1);
|
2016-06-01 10:23:33 +02:00
|
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
pcie_endpoint_cap_common_init(PCIDevice *dev, uint8_t offset, uint8_t cap_size)
|
2013-03-19 19:11:24 +01:00
|
|
|
|
{
|
|
|
|
|
uint8_t type = PCI_EXP_TYPE_ENDPOINT;
|
2017-06-27 08:16:52 +02:00
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
int ret;
|
2013-03-19 19:11:24 +01:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Windows guests will report Code 10, device cannot start, if
|
|
|
|
|
* a regular Endpoint type is exposed on a root complex. These
|
|
|
|
|
* should instead be Root Complex Integrated Endpoints.
|
|
|
|
|
*/
|
2017-11-29 09:46:27 +01:00
|
|
|
|
if (pci_bus_is_express(pci_get_bus(dev))
|
|
|
|
|
&& pci_bus_is_root(pci_get_bus(dev))) {
|
2013-03-19 19:11:24 +01:00
|
|
|
|
type = PCI_EXP_TYPE_RC_END;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-27 08:16:52 +02:00
|
|
|
|
if (cap_size == PCI_EXP_VER1_SIZEOF) {
|
|
|
|
|
return pcie_cap_v1_init(dev, offset, type, 0);
|
|
|
|
|
} else {
|
|
|
|
|
ret = pcie_cap_init(dev, offset, type, 0, &local_err);
|
|
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
error_report_err(local_err);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2016-06-01 10:23:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pcie_endpoint_cap_init(PCIDevice *dev, uint8_t offset)
|
|
|
|
|
{
|
|
|
|
|
return pcie_endpoint_cap_common_init(dev, offset, PCI_EXP_VER2_SIZEOF);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pcie_endpoint_cap_v1_init(PCIDevice *dev, uint8_t offset)
|
|
|
|
|
{
|
|
|
|
|
return pcie_endpoint_cap_common_init(dev, offset, PCI_EXP_VER1_SIZEOF);
|
2013-03-19 19:11:24 +01:00
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
void pcie_cap_exit(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pci_del_capability(dev, PCI_CAP_ID_EXP, PCI_EXP_VER2_SIZEOF);
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-01 10:23:33 +02:00
|
|
|
|
void pcie_cap_v1_exit(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pci_del_capability(dev, PCI_CAP_ID_EXP, PCI_EXP_VER1_SIZEOF);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
uint8_t pcie_cap_get_type(const PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
assert(pos > 0);
|
|
|
|
|
return (pci_get_word(dev->config + pos + PCI_EXP_FLAGS) &
|
|
|
|
|
PCI_EXP_FLAGS_TYPE) >> PCI_EXP_FLAGS_TYPE_SHIFT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* MSI/MSI-X */
|
|
|
|
|
/* pci express interrupt message number */
|
|
|
|
|
/* 7.8.2 PCI Express Capabilities Register: Interrupt Message Number */
|
|
|
|
|
void pcie_cap_flags_set_vector(PCIDevice *dev, uint8_t vector)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *exp_cap = dev->config + dev->exp.exp_cap;
|
|
|
|
|
assert(vector < 32);
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_FLAGS, PCI_EXP_FLAGS_IRQ);
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_FLAGS,
|
|
|
|
|
vector << PCI_EXP_FLAGS_IRQ_SHIFT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t pcie_cap_flags_get_vector(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
return (pci_get_word(dev->config + dev->exp.exp_cap + PCI_EXP_FLAGS) &
|
|
|
|
|
PCI_EXP_FLAGS_IRQ) >> PCI_EXP_FLAGS_IRQ_SHIFT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_deverr_init(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
pci_long_test_and_set_mask(dev->config + pos + PCI_EXP_DEVCAP,
|
|
|
|
|
PCI_EXP_DEVCAP_RBER);
|
|
|
|
|
pci_long_test_and_set_mask(dev->wmask + pos + PCI_EXP_DEVCTL,
|
|
|
|
|
PCI_EXP_DEVCTL_CERE | PCI_EXP_DEVCTL_NFERE |
|
|
|
|
|
PCI_EXP_DEVCTL_FERE | PCI_EXP_DEVCTL_URRE);
|
|
|
|
|
pci_long_test_and_set_mask(dev->w1cmask + pos + PCI_EXP_DEVSTA,
|
|
|
|
|
PCI_EXP_DEVSTA_CED | PCI_EXP_DEVSTA_NFED |
|
2014-11-18 03:47:57 +01:00
|
|
|
|
PCI_EXP_DEVSTA_FED | PCI_EXP_DEVSTA_URD);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_deverr_reset(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *devctl = dev->config + dev->exp.exp_cap + PCI_EXP_DEVCTL;
|
|
|
|
|
pci_long_test_and_clear_mask(devctl,
|
|
|
|
|
PCI_EXP_DEVCTL_CERE | PCI_EXP_DEVCTL_NFERE |
|
|
|
|
|
PCI_EXP_DEVCTL_FERE | PCI_EXP_DEVCTL_URRE);
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-20 21:43:12 +01:00
|
|
|
|
void pcie_cap_lnkctl_init(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
pci_long_test_and_set_mask(dev->wmask + pos + PCI_EXP_LNKCTL,
|
|
|
|
|
PCI_EXP_LNKCTL_CCC | PCI_EXP_LNKCTL_ES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_lnkctl_reset(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *lnkctl = dev->config + dev->exp.exp_cap + PCI_EXP_LNKCTL;
|
|
|
|
|
pci_long_test_and_clear_mask(lnkctl,
|
|
|
|
|
PCI_EXP_LNKCTL_CCC | PCI_EXP_LNKCTL_ES);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 07:46:47 +02:00
|
|
|
|
static void hotplug_event_update_event_status(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
uint8_t *exp_cap = dev->config + pos;
|
|
|
|
|
uint16_t sltctl = pci_get_word(exp_cap + PCI_EXP_SLTCTL);
|
|
|
|
|
uint16_t sltsta = pci_get_word(exp_cap + PCI_EXP_SLTSTA);
|
|
|
|
|
|
|
|
|
|
dev->exp.hpev_notified = (sltctl & PCI_EXP_SLTCTL_HPIE) &&
|
|
|
|
|
(sltsta & sltctl & PCI_EXP_HP_EV_SUPPORTED);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void hotplug_event_notify(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
bool prev = dev->exp.hpev_notified;
|
|
|
|
|
|
|
|
|
|
hotplug_event_update_event_status(dev);
|
|
|
|
|
|
|
|
|
|
if (prev == dev->exp.hpev_notified) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Note: the logic above does not take into account whether interrupts
|
|
|
|
|
* are masked. The result is that interrupt will be sent when it is
|
|
|
|
|
* subsequently unmasked. This appears to be legal: Section 6.7.3.4:
|
|
|
|
|
* The Port may optionally send an MSI when there are hot-plug events that
|
|
|
|
|
* occur while interrupt generation is disabled, and interrupt generation is
|
|
|
|
|
* subsequently enabled. */
|
2010-12-08 09:46:23 +01:00
|
|
|
|
if (msix_enabled(dev)) {
|
|
|
|
|
msix_notify(dev, pcie_cap_flags_get_vector(dev));
|
|
|
|
|
} else if (msi_enabled(dev)) {
|
|
|
|
|
msi_notify(dev, pcie_cap_flags_get_vector(dev));
|
|
|
|
|
} else {
|
2013-10-07 09:36:40 +02:00
|
|
|
|
pci_set_irq(dev, dev->exp.hpev_notified);
|
2010-10-25 07:46:47 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-05 11:22:03 +02:00
|
|
|
|
static void hotplug_event_clear(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
hotplug_event_update_event_status(dev);
|
|
|
|
|
if (!msix_enabled(dev) && !msi_enabled(dev) && !dev->exp.hpev_notified) {
|
2013-10-07 09:36:40 +02:00
|
|
|
|
pci_irq_deassert(dev);
|
2011-08-05 11:22:03 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
/*
|
2011-04-28 17:20:38 +02:00
|
|
|
|
* A PCI Express Hot-Plug Event has occurred, so update slot status register
|
2010-10-19 11:06:34 +02:00
|
|
|
|
* and notify OS of the event if necessary.
|
|
|
|
|
*
|
|
|
|
|
* 6.7.3 PCI Express Hot-Plug Events
|
|
|
|
|
* 6.7.3.4 Software Notification of Hot-Plug Events
|
|
|
|
|
*/
|
|
|
|
|
static void pcie_cap_slot_event(PCIDevice *dev, PCIExpressHotPlugEvent event)
|
|
|
|
|
{
|
2010-10-25 07:46:47 +02:00
|
|
|
|
/* Minor optimization: if nothing changed - no event is needed. */
|
|
|
|
|
if (pci_word_test_and_set_mask(dev->config + dev->exp.exp_cap +
|
2019-06-20 19:44:32 +02:00
|
|
|
|
PCI_EXP_SLTSTA, event) == event) {
|
2010-10-19 11:06:34 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
2010-10-25 07:46:47 +02:00
|
|
|
|
hotplug_event_notify(dev);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:13 +01:00
|
|
|
|
static void pcie_cap_slot_plug_common(PCIDevice *hotplug_dev, DeviceState *dev,
|
2018-12-12 10:16:16 +01:00
|
|
|
|
Error **errp)
|
2010-10-19 11:06:34 +02:00
|
|
|
|
{
|
2018-12-12 10:16:16 +01:00
|
|
|
|
uint8_t *exp_cap = hotplug_dev->config + hotplug_dev->exp.exp_cap;
|
|
|
|
|
uint16_t sltsta = pci_get_word(exp_cap + PCI_EXP_SLTSTA);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
2014-06-23 16:32:47 +02:00
|
|
|
|
PCIE_DEV_PRINTF(PCI_DEVICE(dev), "hotplug state: 0x%x\n", sltsta);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
if (sltsta & PCI_EXP_SLTSTA_EIS) {
|
|
|
|
|
/* the slot is electromechanically locked.
|
|
|
|
|
* This error is propagated up to qdev and then to HMP/QMP.
|
|
|
|
|
*/
|
2014-11-20 09:55:54 +01:00
|
|
|
|
error_setg_errno(errp, EBUSY, "slot is electromechanically locked");
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
2014-02-05 16:36:51 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:16 +01:00
|
|
|
|
void pcie_cap_slot_pre_plug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
|
|
|
|
|
Error **errp)
|
|
|
|
|
{
|
|
|
|
|
pcie_cap_slot_plug_common(PCI_DEVICE(hotplug_dev), dev, errp);
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:13 +01:00
|
|
|
|
void pcie_cap_slot_plug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
|
|
|
|
|
Error **errp)
|
2014-02-05 16:36:51 +01:00
|
|
|
|
{
|
2018-12-12 10:16:16 +01:00
|
|
|
|
PCIDevice *hotplug_pdev = PCI_DEVICE(hotplug_dev);
|
|
|
|
|
uint8_t *exp_cap = hotplug_pdev->config + hotplug_pdev->exp.exp_cap;
|
2014-02-17 15:00:06 +01:00
|
|
|
|
PCIDevice *pci_dev = PCI_DEVICE(dev);
|
2014-02-05 16:36:51 +01:00
|
|
|
|
|
|
|
|
|
/* Don't send event when device is enabled during qemu machine creation:
|
|
|
|
|
* it is present on boot, no hotplug event is necessary. We do send an
|
|
|
|
|
* event when the device is disabled later. */
|
|
|
|
|
if (!dev->hotplugged) {
|
2010-10-19 11:06:34 +02:00
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
|
|
|
|
|
PCI_EXP_SLTSTA_PDS);
|
2018-12-03 08:05:17 +01:00
|
|
|
|
if (pci_dev->cap_present & QEMU_PCIE_LNKSTA_DLLLA) {
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_DLLLA);
|
|
|
|
|
}
|
2014-02-05 16:36:51 +01:00
|
|
|
|
return;
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
2014-02-05 16:36:51 +01:00
|
|
|
|
|
2015-10-28 07:20:31 +01:00
|
|
|
|
/* To enable multifunction hot-plug, we just ensure the function
|
|
|
|
|
* 0 added last. When function 0 is added, we set the sltsta and
|
|
|
|
|
* inform OS via event notification.
|
2014-02-17 15:00:06 +01:00
|
|
|
|
*/
|
2015-10-28 07:20:31 +01:00
|
|
|
|
if (pci_get_function_0(pci_dev)) {
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
|
|
|
|
|
PCI_EXP_SLTSTA_PDS);
|
2018-12-03 08:05:17 +01:00
|
|
|
|
if (pci_dev->cap_present & QEMU_PCIE_LNKSTA_DLLLA) {
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_DLLLA);
|
|
|
|
|
}
|
2015-10-28 07:20:31 +01:00
|
|
|
|
pcie_cap_slot_event(PCI_DEVICE(hotplug_dev),
|
|
|
|
|
PCI_EXP_HP_EV_PDC | PCI_EXP_HP_EV_ABP);
|
|
|
|
|
}
|
2014-02-05 16:36:51 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:20 +01:00
|
|
|
|
void pcie_cap_slot_unplug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
|
|
|
|
|
Error **errp)
|
2015-10-28 07:20:30 +01:00
|
|
|
|
{
|
qdev: Let the hotplug_handler_unplug() caller delete the device
When unplugging a device, at one point the device will be destroyed
via object_unparent(). This will, one the one hand, unrealize the
removed device hierarchy, and on the other hand, destroy/free the
device hierarchy.
When chaining hotplug handlers, we want to overwrite a bus hotplug
handler by the machine hotplug handler, to be able to perform
some part of the plug/unplug and to forward the calls to the bus hotplug
handler.
For now, the bus hotplug handler would trigger an object_unparent(), not
allowing us to perform some unplug action on a device after we forwarded
the call to the bus hotplug handler. The device would be gone at that
point.
machine_unplug_handler(dev)
/* eventually do unplug stuff */
bus_unplug_handler(dev)
/* dev is gone, we can't do more unplug stuff */
So move the object_unparent() to the original caller of the unplug. For
now, keep the unrealize() at the original places of the
object_unparent(). For implicitly chained hotplug handlers (e.g. pc
code calling acpi hotplug handlers), the object_unparent() has to be
done by the outermost caller. So when calling hotplug_handler_unplug()
from inside an unplug handler, nothing is to be done.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> calls unrealize(dev)
/* we can do more unplug stuff but device already unrealized */
}
object_unparent(dev)
In the long run, every unplug action should be factored out of the
unrealize() function into the unplug handler (especially for PCI). Then
we can get rid of the additonal unrealize() calls and object_unparent()
will properly unrealize the device hierarchy after the device has been
unplugged.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> only unplugs, does not unrealize
/* we can do more unplug stuff */
}
object_unparent(dev) -> will unrealize
The original approach was suggested by Igor Mammedov for the PCI
part, but I extended it to all hotplug handlers. I consider this one
step into the right direction.
To summarize:
- object_unparent() on synchronous unplugs is done by common code
-- "Caller of hotplug_handler_unplug"
- object_unparent() on asynchronous unplugs ("unplug requests") has to
be done manually
-- "Caller of hotplug_handler_unplug"
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20190228122849.4296-2-david@redhat.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-02-28 13:28:47 +01:00
|
|
|
|
object_property_set_bool(OBJECT(dev), false, "realized", NULL);
|
2015-10-28 07:20:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:20 +01:00
|
|
|
|
static void pcie_unplug_device(PCIBus *bus, PCIDevice *dev, void *opaque)
|
|
|
|
|
{
|
|
|
|
|
HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(DEVICE(dev));
|
|
|
|
|
|
|
|
|
|
hotplug_handler_unplug(hotplug_ctrl, DEVICE(dev), &error_abort);
|
qdev: Let the hotplug_handler_unplug() caller delete the device
When unplugging a device, at one point the device will be destroyed
via object_unparent(). This will, one the one hand, unrealize the
removed device hierarchy, and on the other hand, destroy/free the
device hierarchy.
When chaining hotplug handlers, we want to overwrite a bus hotplug
handler by the machine hotplug handler, to be able to perform
some part of the plug/unplug and to forward the calls to the bus hotplug
handler.
For now, the bus hotplug handler would trigger an object_unparent(), not
allowing us to perform some unplug action on a device after we forwarded
the call to the bus hotplug handler. The device would be gone at that
point.
machine_unplug_handler(dev)
/* eventually do unplug stuff */
bus_unplug_handler(dev)
/* dev is gone, we can't do more unplug stuff */
So move the object_unparent() to the original caller of the unplug. For
now, keep the unrealize() at the original places of the
object_unparent(). For implicitly chained hotplug handlers (e.g. pc
code calling acpi hotplug handlers), the object_unparent() has to be
done by the outermost caller. So when calling hotplug_handler_unplug()
from inside an unplug handler, nothing is to be done.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> calls unrealize(dev)
/* we can do more unplug stuff but device already unrealized */
}
object_unparent(dev)
In the long run, every unplug action should be factored out of the
unrealize() function into the unplug handler (especially for PCI). Then
we can get rid of the additonal unrealize() calls and object_unparent()
will properly unrealize the device hierarchy after the device has been
unplugged.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> only unplugs, does not unrealize
/* we can do more unplug stuff */
}
object_unparent(dev) -> will unrealize
The original approach was suggested by Igor Mammedov for the PCI
part, but I extended it to all hotplug handlers. I consider this one
step into the right direction.
To summarize:
- object_unparent() on synchronous unplugs is done by common code
-- "Caller of hotplug_handler_unplug"
- object_unparent() on asynchronous unplugs ("unplug requests") has to
be done manually
-- "Caller of hotplug_handler_unplug"
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20190228122849.4296-2-david@redhat.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-02-28 13:28:47 +01:00
|
|
|
|
object_unparent(OBJECT(dev));
|
2018-12-12 10:16:20 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 10:16:13 +01:00
|
|
|
|
void pcie_cap_slot_unplug_request_cb(HotplugHandler *hotplug_dev,
|
|
|
|
|
DeviceState *dev, Error **errp)
|
2014-02-05 16:36:51 +01:00
|
|
|
|
{
|
2018-12-12 10:16:16 +01:00
|
|
|
|
Error *local_err = NULL;
|
2015-10-28 07:20:30 +01:00
|
|
|
|
PCIDevice *pci_dev = PCI_DEVICE(dev);
|
2017-11-29 09:46:27 +01:00
|
|
|
|
PCIBus *bus = pci_get_bus(pci_dev);
|
2014-02-05 16:36:51 +01:00
|
|
|
|
|
2018-12-12 10:16:16 +01:00
|
|
|
|
pcie_cap_slot_plug_common(PCI_DEVICE(hotplug_dev), dev, &local_err);
|
|
|
|
|
if (local_err) {
|
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2014-02-05 16:36:51 +01:00
|
|
|
|
|
2015-10-28 07:20:30 +01:00
|
|
|
|
/* In case user cancel the operation of multi-function hot-add,
|
|
|
|
|
* remove the function that is unexposed to guest individually,
|
|
|
|
|
* without interaction with guest.
|
|
|
|
|
*/
|
|
|
|
|
if (pci_dev->devfn &&
|
|
|
|
|
!bus->devices[0]) {
|
|
|
|
|
pcie_unplug_device(bus, pci_dev, NULL);
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-23 16:32:49 +02:00
|
|
|
|
pcie_cap_slot_push_attention_button(PCI_DEVICE(hotplug_dev));
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* pci express slot for pci express root/downstream port
|
|
|
|
|
PCI express capability slot registers */
|
|
|
|
|
void pcie_cap_slot_init(PCIDevice *dev, uint16_t slot)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
|
|
|
|
|
pci_word_test_and_set_mask(dev->config + pos + PCI_EXP_FLAGS,
|
|
|
|
|
PCI_EXP_FLAGS_SLOT);
|
|
|
|
|
|
|
|
|
|
pci_long_test_and_clear_mask(dev->config + pos + PCI_EXP_SLTCAP,
|
|
|
|
|
~PCI_EXP_SLTCAP_PSN);
|
|
|
|
|
pci_long_test_and_set_mask(dev->config + pos + PCI_EXP_SLTCAP,
|
|
|
|
|
(slot << PCI_EXP_SLTCAP_PSN_SHIFT) |
|
|
|
|
|
PCI_EXP_SLTCAP_EIP |
|
|
|
|
|
PCI_EXP_SLTCAP_HPS |
|
|
|
|
|
PCI_EXP_SLTCAP_HPC |
|
|
|
|
|
PCI_EXP_SLTCAP_PIP |
|
|
|
|
|
PCI_EXP_SLTCAP_AIP |
|
|
|
|
|
PCI_EXP_SLTCAP_ABP);
|
|
|
|
|
|
2014-06-23 16:32:48 +02:00
|
|
|
|
if (dev->cap_present & QEMU_PCIE_SLTCAP_PCP) {
|
|
|
|
|
pci_long_test_and_set_mask(dev->config + pos + PCI_EXP_SLTCAP,
|
|
|
|
|
PCI_EXP_SLTCAP_PCP);
|
|
|
|
|
pci_word_test_and_clear_mask(dev->config + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PCC);
|
|
|
|
|
pci_word_test_and_set_mask(dev->wmask + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PCC);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
pci_word_test_and_clear_mask(dev->config + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PIC |
|
|
|
|
|
PCI_EXP_SLTCTL_AIC);
|
|
|
|
|
pci_word_test_and_set_mask(dev->config + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PIC_OFF |
|
|
|
|
|
PCI_EXP_SLTCTL_AIC_OFF);
|
|
|
|
|
pci_word_test_and_set_mask(dev->wmask + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PIC |
|
|
|
|
|
PCI_EXP_SLTCTL_AIC |
|
|
|
|
|
PCI_EXP_SLTCTL_HPIE |
|
|
|
|
|
PCI_EXP_SLTCTL_CCIE |
|
|
|
|
|
PCI_EXP_SLTCTL_PDCE |
|
|
|
|
|
PCI_EXP_SLTCTL_ABPE);
|
|
|
|
|
/* Although reading PCI_EXP_SLTCTL_EIC returns always 0,
|
|
|
|
|
* make the bit writable here in order to detect 1b is written.
|
|
|
|
|
* pcie_cap_slot_write_config() test-and-clear the bit, so
|
|
|
|
|
* this bit always returns 0 to the guest.
|
|
|
|
|
*/
|
|
|
|
|
pci_word_test_and_set_mask(dev->wmask + pos + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_EIC);
|
|
|
|
|
|
|
|
|
|
pci_word_test_and_set_mask(dev->w1cmask + pos + PCI_EXP_SLTSTA,
|
|
|
|
|
PCI_EXP_HP_EV_SUPPORTED);
|
|
|
|
|
|
2010-10-25 07:46:47 +02:00
|
|
|
|
dev->exp.hpev_notified = false;
|
|
|
|
|
|
2014-02-05 16:36:51 +01:00
|
|
|
|
qbus_set_hotplug_handler(BUS(pci_bridge_get_sec_bus(PCI_BRIDGE(dev))),
|
2019-02-12 19:24:59 +01:00
|
|
|
|
OBJECT(dev), NULL);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_slot_reset(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *exp_cap = dev->config + dev->exp.exp_cap;
|
2014-06-23 16:32:48 +02:00
|
|
|
|
uint8_t port_type = pcie_cap_get_type(dev);
|
|
|
|
|
|
|
|
|
|
assert(port_type == PCI_EXP_TYPE_DOWNSTREAM ||
|
|
|
|
|
port_type == PCI_EXP_TYPE_ROOT_PORT);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
|
|
|
|
PCIE_DEV_PRINTF(dev, "reset\n");
|
|
|
|
|
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_EIC |
|
|
|
|
|
PCI_EXP_SLTCTL_PIC |
|
|
|
|
|
PCI_EXP_SLTCTL_AIC |
|
|
|
|
|
PCI_EXP_SLTCTL_HPIE |
|
|
|
|
|
PCI_EXP_SLTCTL_CCIE |
|
|
|
|
|
PCI_EXP_SLTCTL_PDCE |
|
|
|
|
|
PCI_EXP_SLTCTL_ABPE);
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_AIC_OFF);
|
|
|
|
|
|
2014-06-23 16:32:48 +02:00
|
|
|
|
if (dev->cap_present & QEMU_PCIE_SLTCAP_PCP) {
|
|
|
|
|
/* Downstream ports enforce device number 0. */
|
2014-06-23 16:36:55 +02:00
|
|
|
|
bool populated = pci_bridge_get_sec_bus(PCI_BRIDGE(dev))->devices[0];
|
|
|
|
|
uint16_t pic;
|
2014-06-23 16:32:48 +02:00
|
|
|
|
|
|
|
|
|
if (populated) {
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PCC);
|
|
|
|
|
} else {
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_PCC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pic = populated ? PCI_EXP_SLTCTL_PIC_ON : PCI_EXP_SLTCTL_PIC_OFF;
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTCTL, pic);
|
2014-06-23 16:36:55 +02:00
|
|
|
|
}
|
2014-06-23 16:32:48 +02:00
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTSTA,
|
|
|
|
|
PCI_EXP_SLTSTA_EIS |/* on reset,
|
|
|
|
|
the lock is released */
|
|
|
|
|
PCI_EXP_SLTSTA_CC |
|
|
|
|
|
PCI_EXP_SLTSTA_PDC |
|
|
|
|
|
PCI_EXP_SLTSTA_ABP);
|
2010-10-25 07:46:47 +02:00
|
|
|
|
|
2010-10-27 17:48:42 +02:00
|
|
|
|
hotplug_event_update_event_status(dev);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
pcie: check that slt ctrl changed before deleting
During boot, linux would sometimes overwrites control of a powered off
slot before powering it on. Unfortunately QEMU interprets that as a
power off request and ejects the device.
For example:
/x86_64-softmmu/qemu-system-x86_64 -enable-kvm -S -machine q35 \
-device pcie-root-port,id=pcie_root_port_0,slot=2,chassis=2,addr=0x2,bus=pcie.0 \
-monitor stdio disk.qcow2
(qemu)device_add virtio-balloon-pci,id=balloon,bus=pcie_root_port_0
(qemu)cont
Balloon is deleted during guest boot.
To fix, save control beforehand and check that power
or led state actually change before ejecting.
Note: this is more a hack than a solution, ideally we'd
find a better way to detect ejects, or move away
from ejects completely and instead monitor whether
it's safe to delete device due to e.g. its power state.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Tested-by: Igor Mammedov <imammedo@redhat.com>
2019-06-21 06:12:22 +02:00
|
|
|
|
void pcie_cap_slot_get(PCIDevice *dev, uint16_t *slt_ctl, uint16_t *slt_sta)
|
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
uint8_t *exp_cap = dev->config + pos;
|
|
|
|
|
*slt_ctl = pci_get_word(exp_cap + PCI_EXP_SLTCTL);
|
|
|
|
|
*slt_sta = pci_get_word(exp_cap + PCI_EXP_SLTSTA);
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-01 11:29:51 +02:00
|
|
|
|
void pcie_cap_slot_write_config(PCIDevice *dev,
|
|
|
|
|
uint16_t old_slt_ctl, uint16_t old_slt_sta,
|
2010-10-25 07:46:47 +02:00
|
|
|
|
uint32_t addr, uint32_t val, int len)
|
2010-10-19 11:06:34 +02:00
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
uint8_t *exp_cap = dev->config + pos;
|
|
|
|
|
uint16_t sltsta = pci_get_word(exp_cap + PCI_EXP_SLTSTA);
|
|
|
|
|
|
2011-08-05 11:22:03 +02:00
|
|
|
|
if (ranges_overlap(addr, len, pos + PCI_EXP_SLTSTA, 2)) {
|
pcie: work around for racy guest init
During boot, linux guests tend to clear all bits in pcie slot status
register which is used for hotplug.
If they clear bits that weren't set this is racy and will lose events:
not a big problem for manual hotplug on bare-metal, but a problem for us.
For example, the following is broken ATM:
/x86_64-softmmu/qemu-system-x86_64 -enable-kvm -S -machine q35 \
-device pcie-root-port,id=pcie_root_port_0,slot=2,chassis=2,addr=0x2,bus=pcie.0 \
-device virtio-balloon-pci,id=balloon,bus=pcie_root_port_0 \
-monitor stdio disk.qcow2
(qemu)device_del balloon
(qemu)cont
Balloon isn't deleted as it should.
As a work-around, detect this attempt to clear slot status and revert
status to what it was before the write.
Note: in theory this can be detected as a duplicate button press
which cancels the previous press. Does not seem to happen in
practice as guests seem to only have this bug during init.
Note2: the right thing to do is probably to fix Linux to
read status before clearing it, and act on the bits that are set.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Tested-by: Igor Mammedov <imammedo@redhat.com>
2019-06-21 08:38:41 +02:00
|
|
|
|
/*
|
|
|
|
|
* Guests tend to clears all bits during init.
|
|
|
|
|
* If they clear bits that weren't set this is racy and will lose events:
|
|
|
|
|
* not a big problem for manual button presses, but a problem for us.
|
|
|
|
|
* As a work-around, detect this and revert status to what it was
|
|
|
|
|
* before the write.
|
|
|
|
|
*
|
|
|
|
|
* Note: in theory this can be detected as a duplicate button press
|
|
|
|
|
* which cancels the previous press. Does not seem to happen in
|
|
|
|
|
* practice as guests seem to only have this bug during init.
|
|
|
|
|
*/
|
|
|
|
|
#define PCIE_SLOT_EVENTS (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD | \
|
|
|
|
|
PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC | \
|
|
|
|
|
PCI_EXP_SLTSTA_CC)
|
|
|
|
|
|
2019-07-01 11:29:51 +02:00
|
|
|
|
if (val & ~old_slt_sta & PCIE_SLOT_EVENTS) {
|
|
|
|
|
sltsta = (sltsta & ~PCIE_SLOT_EVENTS) | (old_slt_sta & PCIE_SLOT_EVENTS);
|
pcie: work around for racy guest init
During boot, linux guests tend to clear all bits in pcie slot status
register which is used for hotplug.
If they clear bits that weren't set this is racy and will lose events:
not a big problem for manual hotplug on bare-metal, but a problem for us.
For example, the following is broken ATM:
/x86_64-softmmu/qemu-system-x86_64 -enable-kvm -S -machine q35 \
-device pcie-root-port,id=pcie_root_port_0,slot=2,chassis=2,addr=0x2,bus=pcie.0 \
-device virtio-balloon-pci,id=balloon,bus=pcie_root_port_0 \
-monitor stdio disk.qcow2
(qemu)device_del balloon
(qemu)cont
Balloon isn't deleted as it should.
As a work-around, detect this attempt to clear slot status and revert
status to what it was before the write.
Note: in theory this can be detected as a duplicate button press
which cancels the previous press. Does not seem to happen in
practice as guests seem to only have this bug during init.
Note2: the right thing to do is probably to fix Linux to
read status before clearing it, and act on the bits that are set.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Tested-by: Igor Mammedov <imammedo@redhat.com>
2019-06-21 08:38:41 +02:00
|
|
|
|
pci_set_word(exp_cap + PCI_EXP_SLTSTA, sltsta);
|
|
|
|
|
}
|
2011-08-05 11:22:03 +02:00
|
|
|
|
hotplug_event_clear(dev);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 07:03:24 +02:00
|
|
|
|
if (!ranges_overlap(addr, len, pos + PCI_EXP_SLTCTL, 2)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTCTL,
|
|
|
|
|
PCI_EXP_SLTCTL_EIC)) {
|
|
|
|
|
sltsta ^= PCI_EXP_SLTSTA_EIS; /* toggle PCI_EXP_SLTSTA_EIS bit */
|
|
|
|
|
pci_set_word(exp_cap + PCI_EXP_SLTSTA, sltsta);
|
|
|
|
|
PCIE_DEV_PRINTF(dev, "PCI_EXP_SLTCTL_EIC: "
|
|
|
|
|
"sltsta -> 0x%02"PRIx16"\n",
|
|
|
|
|
sltsta);
|
|
|
|
|
}
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
2014-06-23 16:32:49 +02:00
|
|
|
|
/*
|
2019-07-01 11:29:51 +02:00
|
|
|
|
* If the slot is populated, power indicator is off and power
|
2014-06-23 16:32:49 +02:00
|
|
|
|
* controller is off, it is safe to detach the devices.
|
2019-07-01 11:29:51 +02:00
|
|
|
|
*
|
|
|
|
|
* Note: don't detach if condition was already true:
|
|
|
|
|
* this is a work around for guests that overwrite
|
|
|
|
|
* control of powered off slots before powering them on.
|
2014-06-23 16:32:49 +02:00
|
|
|
|
*/
|
|
|
|
|
if ((sltsta & PCI_EXP_SLTSTA_PDS) && (val & PCI_EXP_SLTCTL_PCC) &&
|
pcie: check that slt ctrl changed before deleting
During boot, linux would sometimes overwrites control of a powered off
slot before powering it on. Unfortunately QEMU interprets that as a
power off request and ejects the device.
For example:
/x86_64-softmmu/qemu-system-x86_64 -enable-kvm -S -machine q35 \
-device pcie-root-port,id=pcie_root_port_0,slot=2,chassis=2,addr=0x2,bus=pcie.0 \
-monitor stdio disk.qcow2
(qemu)device_add virtio-balloon-pci,id=balloon,bus=pcie_root_port_0
(qemu)cont
Balloon is deleted during guest boot.
To fix, save control beforehand and check that power
or led state actually change before ejecting.
Note: this is more a hack than a solution, ideally we'd
find a better way to detect ejects, or move away
from ejects completely and instead monitor whether
it's safe to delete device due to e.g. its power state.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Tested-by: Igor Mammedov <imammedo@redhat.com>
2019-06-21 06:12:22 +02:00
|
|
|
|
(val & PCI_EXP_SLTCTL_PIC_OFF) == PCI_EXP_SLTCTL_PIC_OFF &&
|
2019-07-01 11:29:51 +02:00
|
|
|
|
(!(old_slt_ctl & PCI_EXP_SLTCTL_PCC) ||
|
|
|
|
|
(old_slt_ctl & PCI_EXP_SLTCTL_PIC_OFF) != PCI_EXP_SLTCTL_PIC_OFF)) {
|
2015-10-25 09:23:28 +01:00
|
|
|
|
PCIBus *sec_bus = pci_bridge_get_sec_bus(PCI_BRIDGE(dev));
|
|
|
|
|
pci_for_each_device(sec_bus, pci_bus_num(sec_bus),
|
|
|
|
|
pcie_unplug_device, NULL);
|
2014-06-23 16:32:49 +02:00
|
|
|
|
|
2015-10-25 09:23:28 +01:00
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTSTA,
|
|
|
|
|
PCI_EXP_SLTSTA_PDS);
|
2018-12-03 08:05:17 +01:00
|
|
|
|
if (dev->cap_present & QEMU_PCIE_LNKSTA_DLLLA) {
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_DLLLA);
|
|
|
|
|
}
|
2015-10-25 09:23:28 +01:00
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
|
2014-06-23 16:32:49 +02:00
|
|
|
|
PCI_EXP_SLTSTA_PDC);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 07:46:47 +02:00
|
|
|
|
hotplug_event_notify(dev);
|
2010-10-25 07:03:24 +02:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 6.7.3.2 Command Completed Events
|
|
|
|
|
*
|
|
|
|
|
* Software issues a command to a hot-plug capable Downstream Port by
|
|
|
|
|
* issuing a write transaction that targets any portion of the Port’s Slot
|
|
|
|
|
* Control register. A single write to the Slot Control register is
|
|
|
|
|
* considered to be a single command, even if the write affects more than
|
|
|
|
|
* one field in the Slot Control register. In response to this transaction,
|
|
|
|
|
* the Port must carry out the requested actions and then set the
|
|
|
|
|
* associated status field for the command completed event. */
|
|
|
|
|
|
|
|
|
|
/* Real hardware might take a while to complete requested command because
|
|
|
|
|
* physical movement would be involved like locking the electromechanical
|
|
|
|
|
* lock. However in our case, command is completed instantaneously above,
|
|
|
|
|
* so send a command completion event right now.
|
|
|
|
|
*/
|
|
|
|
|
pcie_cap_slot_event(dev, PCI_EXP_HP_EV_CCI);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 07:46:47 +02:00
|
|
|
|
int pcie_cap_slot_post_load(void *opaque, int version_id)
|
|
|
|
|
{
|
|
|
|
|
PCIDevice *dev = opaque;
|
|
|
|
|
hotplug_event_update_event_status(dev);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
void pcie_cap_slot_push_attention_button(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pcie_cap_slot_event(dev, PCI_EXP_HP_EV_ABP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* root control/capabilities/status. PME isn't emulated for now */
|
|
|
|
|
void pcie_cap_root_init(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pci_set_word(dev->wmask + dev->exp.exp_cap + PCI_EXP_RTCTL,
|
|
|
|
|
PCI_EXP_RTCTL_SECEE | PCI_EXP_RTCTL_SENFEE |
|
|
|
|
|
PCI_EXP_RTCTL_SEFEE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_root_reset(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pci_set_word(dev->config + dev->exp.exp_cap + PCI_EXP_RTCTL, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* function level reset(FLR) */
|
|
|
|
|
void pcie_cap_flr_init(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
pci_long_test_and_set_mask(dev->config + dev->exp.exp_cap + PCI_EXP_DEVCAP,
|
|
|
|
|
PCI_EXP_DEVCAP_FLR);
|
|
|
|
|
|
|
|
|
|
/* Although reading BCR_FLR returns always 0,
|
|
|
|
|
* the bit is made writable here in order to detect the 1b is written
|
|
|
|
|
* pcie_cap_flr_write_config() test-and-clear the bit, so
|
|
|
|
|
* this bit always returns 0 to the guest.
|
|
|
|
|
*/
|
|
|
|
|
pci_word_test_and_set_mask(dev->wmask + dev->exp.exp_cap + PCI_EXP_DEVCTL,
|
|
|
|
|
PCI_EXP_DEVCTL_BCR_FLR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_cap_flr_write_config(PCIDevice *dev,
|
|
|
|
|
uint32_t addr, uint32_t val, int len)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *devctl = dev->config + dev->exp.exp_cap + PCI_EXP_DEVCTL;
|
2010-12-22 07:14:35 +01:00
|
|
|
|
if (pci_get_word(devctl) & PCI_EXP_DEVCTL_BCR_FLR) {
|
|
|
|
|
/* Clear PCI_EXP_DEVCTL_BCR_FLR after invoking the reset handler
|
|
|
|
|
so the handler can detect FLR by looking at this bit. */
|
|
|
|
|
pci_device_reset(dev);
|
|
|
|
|
pci_word_test_and_clear_mask(devctl, PCI_EXP_DEVCTL_BCR_FLR);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-24 15:32:18 +02:00
|
|
|
|
/* Alternative Routing-ID Interpretation (ARI)
|
2014-08-24 22:45:29 +02:00
|
|
|
|
* forwarding support for root and downstream ports
|
2014-08-24 15:32:18 +02:00
|
|
|
|
*/
|
|
|
|
|
void pcie_cap_arifwd_init(PCIDevice *dev)
|
2010-10-19 11:06:34 +02:00
|
|
|
|
{
|
|
|
|
|
uint32_t pos = dev->exp.exp_cap;
|
|
|
|
|
pci_long_test_and_set_mask(dev->config + pos + PCI_EXP_DEVCAP2,
|
|
|
|
|
PCI_EXP_DEVCAP2_ARI);
|
|
|
|
|
pci_long_test_and_set_mask(dev->wmask + pos + PCI_EXP_DEVCTL2,
|
|
|
|
|
PCI_EXP_DEVCTL2_ARI);
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-24 15:32:18 +02:00
|
|
|
|
void pcie_cap_arifwd_reset(PCIDevice *dev)
|
2010-10-19 11:06:34 +02:00
|
|
|
|
{
|
|
|
|
|
uint8_t *devctl2 = dev->config + dev->exp.exp_cap + PCI_EXP_DEVCTL2;
|
|
|
|
|
pci_long_test_and_clear_mask(devctl2, PCI_EXP_DEVCTL2_ARI);
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-24 15:32:18 +02:00
|
|
|
|
bool pcie_cap_is_arifwd_enabled(const PCIDevice *dev)
|
2010-10-19 11:06:34 +02:00
|
|
|
|
{
|
|
|
|
|
if (!pci_is_express(dev)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
if (!dev->exp.exp_cap) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return pci_get_long(dev->config + dev->exp.exp_cap + PCI_EXP_DEVCTL2) &
|
|
|
|
|
PCI_EXP_DEVCTL2_ARI;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**************************************************************************
|
2014-10-07 08:53:48 +02:00
|
|
|
|
* pci express extended capability list management functions
|
2010-10-19 11:06:34 +02:00
|
|
|
|
* uint16_t ext_cap_id (16 bit)
|
|
|
|
|
* uint8_t cap_ver (4 bit)
|
|
|
|
|
* uint16_t cap_offset (12 bit)
|
|
|
|
|
* uint16_t ext_cap_size
|
|
|
|
|
*/
|
|
|
|
|
|
2017-02-15 21:37:45 +01:00
|
|
|
|
/* Passing a cap_id value > 0xffff will return 0 and put end of list in prev */
|
|
|
|
|
static uint16_t pcie_find_capability_list(PCIDevice *dev, uint32_t cap_id,
|
2010-10-19 11:06:34 +02:00
|
|
|
|
uint16_t *prev_p)
|
|
|
|
|
{
|
|
|
|
|
uint16_t prev = 0;
|
|
|
|
|
uint16_t next;
|
|
|
|
|
uint32_t header = pci_get_long(dev->config + PCI_CONFIG_SPACE_SIZE);
|
|
|
|
|
|
|
|
|
|
if (!header) {
|
|
|
|
|
/* no extended capability */
|
|
|
|
|
next = 0;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
for (next = PCI_CONFIG_SPACE_SIZE; next;
|
|
|
|
|
prev = next, next = PCI_EXT_CAP_NEXT(header)) {
|
|
|
|
|
|
|
|
|
|
assert(next >= PCI_CONFIG_SPACE_SIZE);
|
|
|
|
|
assert(next <= PCIE_CONFIG_SPACE_SIZE - 8);
|
|
|
|
|
|
|
|
|
|
header = pci_get_long(dev->config + next);
|
|
|
|
|
if (PCI_EXT_CAP_ID(header) == cap_id) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
if (prev_p) {
|
|
|
|
|
*prev_p = prev;
|
|
|
|
|
}
|
|
|
|
|
return next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint16_t pcie_find_capability(PCIDevice *dev, uint16_t cap_id)
|
|
|
|
|
{
|
|
|
|
|
return pcie_find_capability_list(dev, cap_id, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pcie_ext_cap_set_next(PCIDevice *dev, uint16_t pos, uint16_t next)
|
|
|
|
|
{
|
2012-12-18 22:36:29 +01:00
|
|
|
|
uint32_t header = pci_get_long(dev->config + pos);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
assert(!(next & (PCI_EXT_CAP_ALIGN - 1)));
|
|
|
|
|
header = (header & ~PCI_EXT_CAP_NEXT_MASK) |
|
|
|
|
|
((next << PCI_EXT_CAP_NEXT_SHIFT) & PCI_EXT_CAP_NEXT_MASK);
|
|
|
|
|
pci_set_long(dev->config + pos, header);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2016-11-11 04:02:48 +01:00
|
|
|
|
* Caller must supply valid (offset, size) such that the range wouldn't
|
2010-10-19 11:06:34 +02:00
|
|
|
|
* overlap with other capability or other registers.
|
|
|
|
|
* This function doesn't check it.
|
|
|
|
|
*/
|
|
|
|
|
void pcie_add_capability(PCIDevice *dev,
|
|
|
|
|
uint16_t cap_id, uint8_t cap_ver,
|
|
|
|
|
uint16_t offset, uint16_t size)
|
|
|
|
|
{
|
|
|
|
|
assert(offset >= PCI_CONFIG_SPACE_SIZE);
|
|
|
|
|
assert(offset < offset + size);
|
2016-02-19 17:42:27 +01:00
|
|
|
|
assert(offset + size <= PCIE_CONFIG_SPACE_SIZE);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
assert(size >= 8);
|
|
|
|
|
assert(pci_is_express(dev));
|
|
|
|
|
|
2017-02-16 05:06:01 +01:00
|
|
|
|
if (offset != PCI_CONFIG_SPACE_SIZE) {
|
2010-10-19 11:06:34 +02:00
|
|
|
|
uint16_t prev;
|
|
|
|
|
|
2017-02-15 21:37:45 +01:00
|
|
|
|
/*
|
|
|
|
|
* 0xffffffff is not a valid cap id (it's a 16 bit field). use
|
|
|
|
|
* internally to find the last capability in the linked list.
|
|
|
|
|
*/
|
2017-02-16 05:06:01 +01:00
|
|
|
|
pcie_find_capability_list(dev, 0xffffffff, &prev);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
assert(prev >= PCI_CONFIG_SPACE_SIZE);
|
|
|
|
|
pcie_ext_cap_set_next(dev, prev, offset);
|
|
|
|
|
}
|
2017-02-16 05:06:01 +01:00
|
|
|
|
pci_set_long(dev->config + offset, PCI_EXT_CAP(cap_id, cap_ver, 0));
|
2010-10-19 11:06:34 +02:00
|
|
|
|
|
|
|
|
|
/* Make capability read-only by default */
|
|
|
|
|
memset(dev->wmask + offset, 0, size);
|
|
|
|
|
memset(dev->w1cmask + offset, 0, size);
|
|
|
|
|
/* Check capability by default */
|
|
|
|
|
memset(dev->cmask + offset, 0xFF, size);
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-12 20:38:55 +01:00
|
|
|
|
/*
|
|
|
|
|
* Sync the PCIe Link Status negotiated speed and width of a bridge with the
|
|
|
|
|
* downstream device. If downstream device is not present, re-write with the
|
2019-02-19 20:06:43 +01:00
|
|
|
|
* Link Capability fields. If downstream device reports invalid width or
|
|
|
|
|
* speed, replace with minimum values (LnkSta fields are RsvdZ on VFs but such
|
|
|
|
|
* values interfere with PCIe native hotplug detecting new devices). Limit
|
|
|
|
|
* width and speed to bridge capabilities for compatibility. Use config_read
|
|
|
|
|
* to access the downstream device since it could be an assigned device with
|
|
|
|
|
* volatile link information.
|
2018-12-12 20:38:55 +01:00
|
|
|
|
*/
|
|
|
|
|
void pcie_sync_bridge_lnk(PCIDevice *bridge_dev)
|
|
|
|
|
{
|
|
|
|
|
PCIBridge *br = PCI_BRIDGE(bridge_dev);
|
|
|
|
|
PCIBus *bus = pci_bridge_get_sec_bus(br);
|
|
|
|
|
PCIDevice *target = bus->devices[0];
|
|
|
|
|
uint8_t *exp_cap = bridge_dev->config + bridge_dev->exp.exp_cap;
|
|
|
|
|
uint16_t lnksta, lnkcap = pci_get_word(exp_cap + PCI_EXP_LNKCAP);
|
|
|
|
|
|
|
|
|
|
if (!target || !target->exp.exp_cap) {
|
|
|
|
|
lnksta = lnkcap;
|
|
|
|
|
} else {
|
|
|
|
|
lnksta = target->config_read(target,
|
|
|
|
|
target->exp.exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
sizeof(lnksta));
|
|
|
|
|
|
|
|
|
|
if ((lnksta & PCI_EXP_LNKSTA_NLW) > (lnkcap & PCI_EXP_LNKCAP_MLW)) {
|
|
|
|
|
lnksta &= ~PCI_EXP_LNKSTA_NLW;
|
|
|
|
|
lnksta |= lnkcap & PCI_EXP_LNKCAP_MLW;
|
2019-02-19 20:06:43 +01:00
|
|
|
|
} else if (!(lnksta & PCI_EXP_LNKSTA_NLW)) {
|
|
|
|
|
lnksta |= QEMU_PCI_EXP_LNKSTA_NLW(QEMU_PCI_EXP_LNK_X1);
|
2018-12-12 20:38:55 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((lnksta & PCI_EXP_LNKSTA_CLS) > (lnkcap & PCI_EXP_LNKCAP_SLS)) {
|
|
|
|
|
lnksta &= ~PCI_EXP_LNKSTA_CLS;
|
|
|
|
|
lnksta |= lnkcap & PCI_EXP_LNKCAP_SLS;
|
2019-02-19 20:06:43 +01:00
|
|
|
|
} else if (!(lnksta & PCI_EXP_LNKSTA_CLS)) {
|
|
|
|
|
lnksta |= QEMU_PCI_EXP_LNKSTA_CLS(QEMU_PCI_EXP_LNK_2_5GT);
|
2018-12-12 20:38:55 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pci_word_test_and_clear_mask(exp_cap + PCI_EXP_LNKSTA,
|
|
|
|
|
PCI_EXP_LNKSTA_CLS | PCI_EXP_LNKSTA_NLW);
|
|
|
|
|
pci_word_test_and_set_mask(exp_cap + PCI_EXP_LNKSTA, lnksta &
|
|
|
|
|
(PCI_EXP_LNKSTA_CLS | PCI_EXP_LNKSTA_NLW));
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-19 11:06:34 +02:00
|
|
|
|
/**************************************************************************
|
|
|
|
|
* pci express extended capability helper functions
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* ARI */
|
|
|
|
|
void pcie_ari_init(PCIDevice *dev, uint16_t offset, uint16_t nextfn)
|
|
|
|
|
{
|
|
|
|
|
pcie_add_capability(dev, PCI_EXT_CAP_ID_ARI, PCI_ARI_VER,
|
|
|
|
|
offset, PCI_ARI_SIZEOF);
|
2014-08-24 15:32:17 +02:00
|
|
|
|
pci_set_long(dev->config + offset + PCI_ARI_CAP, (nextfn & 0xff) << 8);
|
2010-10-19 11:06:34 +02:00
|
|
|
|
}
|
2016-06-01 10:23:34 +02:00
|
|
|
|
|
|
|
|
|
void pcie_dev_ser_num_init(PCIDevice *dev, uint16_t offset, uint64_t ser_num)
|
|
|
|
|
{
|
|
|
|
|
static const int pci_dsn_ver = 1;
|
|
|
|
|
static const int pci_dsn_cap = 4;
|
|
|
|
|
|
|
|
|
|
pcie_add_capability(dev, PCI_EXT_CAP_ID_DSN, pci_dsn_ver, offset,
|
|
|
|
|
PCI_EXT_CAP_DSN_SIZEOF);
|
|
|
|
|
pci_set_quad(dev->config + offset + pci_dsn_cap, ser_num);
|
|
|
|
|
}
|
2016-12-30 11:09:15 +01:00
|
|
|
|
|
|
|
|
|
void pcie_ats_init(PCIDevice *dev, uint16_t offset)
|
|
|
|
|
{
|
|
|
|
|
pcie_add_capability(dev, PCI_EXT_CAP_ID_ATS, 0x1,
|
|
|
|
|
offset, PCI_EXT_CAP_ATS_SIZEOF);
|
|
|
|
|
|
|
|
|
|
dev->exp.ats_cap = offset;
|
|
|
|
|
|
|
|
|
|
/* Invalidate Queue Depth 0, Page Aligned Request 0 */
|
|
|
|
|
pci_set_word(dev->config + offset + PCI_ATS_CAP, 0);
|
|
|
|
|
/* STU 0, Disabled by default */
|
|
|
|
|
pci_set_word(dev->config + offset + PCI_ATS_CTRL, 0);
|
|
|
|
|
|
|
|
|
|
pci_set_word(dev->wmask + dev->exp.ats_cap + PCI_ATS_CTRL, 0x800f);
|
|
|
|
|
}
|
2019-02-21 19:13:22 +01:00
|
|
|
|
|
|
|
|
|
/* ACS (Access Control Services) */
|
|
|
|
|
void pcie_acs_init(PCIDevice *dev, uint16_t offset)
|
|
|
|
|
{
|
|
|
|
|
bool is_downstream = pci_is_express_downstream_port(dev);
|
|
|
|
|
uint16_t cap_bits = 0;
|
|
|
|
|
|
|
|
|
|
/* For endpoints, only multifunction devs may have an ACS capability: */
|
|
|
|
|
assert(is_downstream ||
|
|
|
|
|
(dev->cap_present & QEMU_PCI_CAP_MULTIFUNCTION) ||
|
|
|
|
|
PCI_FUNC(dev->devfn));
|
|
|
|
|
|
|
|
|
|
pcie_add_capability(dev, PCI_EXT_CAP_ID_ACS, PCI_ACS_VER, offset,
|
|
|
|
|
PCI_ACS_SIZEOF);
|
|
|
|
|
dev->exp.acs_cap = offset;
|
|
|
|
|
|
|
|
|
|
if (is_downstream) {
|
|
|
|
|
/*
|
|
|
|
|
* Downstream ports must implement SV, TB, RR, CR, UF, and DT (with
|
|
|
|
|
* caveats on the latter four that we ignore for simplicity).
|
|
|
|
|
* Endpoints may also implement a subset of ACS capabilities,
|
|
|
|
|
* but these are optional if the endpoint does not support
|
|
|
|
|
* peer-to-peer between functions and thus omitted here.
|
|
|
|
|
*/
|
|
|
|
|
cap_bits = PCI_ACS_SV | PCI_ACS_TB | PCI_ACS_RR |
|
|
|
|
|
PCI_ACS_CR | PCI_ACS_UF | PCI_ACS_DT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pci_set_word(dev->config + offset + PCI_ACS_CAP, cap_bits);
|
|
|
|
|
pci_set_word(dev->wmask + offset + PCI_ACS_CTRL, cap_bits);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pcie_acs_reset(PCIDevice *dev)
|
|
|
|
|
{
|
|
|
|
|
if (dev->exp.acs_cap) {
|
|
|
|
|
pci_set_word(dev->config + dev->exp.acs_cap + PCI_ACS_CTRL, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|