2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* File: portdrv_core.c
|
|
|
|
* Purpose: PCI Express Port Bus Driver's Core Functions
|
|
|
|
*
|
|
|
|
* Copyright (C) 2004 Intel
|
|
|
|
* Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/pm.h>
|
2005-10-31 07:03:48 +08:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/slab.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/pcieport_if.h>
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
#include <linux/aer.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-01-13 21:38:34 +08:00
|
|
|
#include "../pci.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
#include "portdrv.h"
|
|
|
|
|
2012-02-03 00:09:22 +08:00
|
|
|
bool pciehp_msi_disabled;
|
|
|
|
|
|
|
|
static int __init pciehp_setup(char *str)
|
|
|
|
{
|
|
|
|
if (!strncmp(str, "nomsi", 5))
|
|
|
|
pciehp_msi_disabled = true;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("pcie_hp=", pciehp_setup);
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* release_pcie_device - free PCI Express port service device structure
|
|
|
|
* @dev: Port service device to release
|
|
|
|
*
|
|
|
|
* Invoked automatically when device is being removed in response to
|
|
|
|
* device_unregister(dev). Release all resources being claimed.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
static void release_pcie_device(struct device *dev)
|
|
|
|
{
|
2009-12-15 10:38:04 +08:00
|
|
|
kfree(to_pcie_device(dev));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-24 07:23:22 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_msix_add_entry - add entry to given array of MSI-X entries
|
|
|
|
* @entries: Array of MSI-X entries
|
|
|
|
* @new_entry: Index of the entry to add to the array
|
|
|
|
* @nr_entries: Number of entries aleady in the array
|
|
|
|
*
|
|
|
|
* Return value: Position of the added entry in the array
|
|
|
|
*/
|
|
|
|
static int pcie_port_msix_add_entry(
|
|
|
|
struct msix_entry *entries, int new_entry, int nr_entries)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
for (j = 0; j < nr_entries; j++)
|
|
|
|
if (entries[j].entry == new_entry)
|
|
|
|
return j;
|
|
|
|
|
|
|
|
entries[j].entry = new_entry;
|
|
|
|
return j;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcie_port_enable_msix - try to set up MSI-X as interrupt mode for given port
|
|
|
|
* @dev: PCI Express port to handle
|
|
|
|
* @vectors: Array of interrupt vectors to populate
|
|
|
|
* @mask: Bitmask of port capabilities returned by get_port_device_capability()
|
|
|
|
*
|
|
|
|
* Return value: 0 on success, error code on failure
|
|
|
|
*/
|
|
|
|
static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
|
|
|
|
{
|
|
|
|
struct msix_entry *msix_entries;
|
|
|
|
int idx[PCIE_PORT_DEVICE_MAXSERVICES];
|
|
|
|
int nr_entries, status, pos, i, nvec;
|
|
|
|
u16 reg16;
|
|
|
|
u32 reg32;
|
|
|
|
|
|
|
|
nr_entries = pci_msix_table_size(dev);
|
|
|
|
if (!nr_entries)
|
|
|
|
return -EINVAL;
|
|
|
|
if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
|
|
|
|
nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
|
|
|
|
|
|
|
|
msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL);
|
|
|
|
if (!msix_entries)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate as many entries as the port wants, so that we can check
|
|
|
|
* which of them will be useful. Moreover, if nr_entries is correctly
|
|
|
|
* equal to the number of entries this port actually uses, we'll happily
|
|
|
|
* go through without any tricks.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < nr_entries; i++)
|
|
|
|
msix_entries[i].entry = i;
|
|
|
|
|
|
|
|
status = pci_enable_msix(dev, msix_entries, nr_entries);
|
|
|
|
if (status)
|
|
|
|
goto Exit;
|
|
|
|
|
|
|
|
for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
|
|
|
|
idx[i] = -1;
|
|
|
|
status = -EIO;
|
|
|
|
nvec = 0;
|
|
|
|
|
|
|
|
if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
|
|
|
|
int entry;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The code below follows the PCI Express Base Specification 2.0
|
|
|
|
* stating in Section 6.1.6 that "PME and Hot-Plug Event
|
|
|
|
* interrupts (when both are implemented) always share the same
|
|
|
|
* MSI or MSI-X vector, as indicated by the Interrupt Message
|
|
|
|
* Number field in the PCI Express Capabilities register", where
|
|
|
|
* according to Section 7.8.2 of the specification "For MSI-X,
|
|
|
|
* the value in this field indicates which MSI-X Table entry is
|
|
|
|
* used to generate the interrupt message."
|
|
|
|
*/
|
2012-12-06 04:51:18 +08:00
|
|
|
pcie_capability_read_word(dev, PCI_EXP_FLAGS, ®16);
|
2009-11-25 20:06:51 +08:00
|
|
|
entry = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
|
2009-01-24 07:23:22 +08:00
|
|
|
if (entry >= nr_entries)
|
|
|
|
goto Error;
|
|
|
|
|
|
|
|
i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
|
|
|
|
if (i == nvec)
|
|
|
|
nvec++;
|
|
|
|
|
|
|
|
idx[PCIE_PORT_SERVICE_PME_SHIFT] = i;
|
|
|
|
idx[PCIE_PORT_SERVICE_HP_SHIFT] = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mask & PCIE_PORT_SERVICE_AER) {
|
|
|
|
int entry;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The code below follows Section 7.10.10 of the PCI Express
|
|
|
|
* Base Specification 2.0 stating that bits 31-27 of the Root
|
|
|
|
* Error Status Register contain a value indicating which of the
|
|
|
|
* MSI/MSI-X vectors assigned to the port is going to be used
|
|
|
|
* for AER, where "For MSI-X, the value in this register
|
|
|
|
* indicates which MSI-X Table entry is used to generate the
|
|
|
|
* interrupt message."
|
|
|
|
*/
|
|
|
|
pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
|
|
|
|
pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, ®32);
|
|
|
|
entry = reg32 >> 27;
|
|
|
|
if (entry >= nr_entries)
|
|
|
|
goto Error;
|
|
|
|
|
|
|
|
i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
|
|
|
|
if (i == nvec)
|
|
|
|
nvec++;
|
|
|
|
|
|
|
|
idx[PCIE_PORT_SERVICE_AER_SHIFT] = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If nvec is equal to the allocated number of entries, we can just use
|
|
|
|
* what we have. Otherwise, the port has some extra entries not for the
|
|
|
|
* services we know and we need to work around that.
|
|
|
|
*/
|
|
|
|
if (nvec == nr_entries) {
|
|
|
|
status = 0;
|
|
|
|
} else {
|
|
|
|
/* Drop the temporary MSI-X setup */
|
|
|
|
pci_disable_msix(dev);
|
|
|
|
|
|
|
|
/* Now allocate the MSI-X vectors for real */
|
|
|
|
status = pci_enable_msix(dev, msix_entries, nvec);
|
|
|
|
if (status)
|
|
|
|
goto Exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
|
|
|
|
vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1;
|
|
|
|
|
|
|
|
Exit:
|
|
|
|
kfree(msix_entries);
|
|
|
|
return status;
|
|
|
|
|
|
|
|
Error:
|
|
|
|
pci_disable_msix(dev);
|
|
|
|
goto Exit;
|
|
|
|
}
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
2009-11-25 20:04:00 +08:00
|
|
|
* init_service_irqs - initialize irqs for PCI Express port services
|
2009-01-02 02:48:55 +08:00
|
|
|
* @dev: PCI Express port to handle
|
2009-11-25 20:04:00 +08:00
|
|
|
* @irqs: Array of irqs to populate
|
2009-01-02 02:48:55 +08:00
|
|
|
* @mask: Bitmask of port capabilities returned by get_port_device_capability()
|
|
|
|
*
|
|
|
|
* Return value: Interrupt mode associated with the port
|
|
|
|
*/
|
2009-11-25 20:04:00 +08:00
|
|
|
static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-02-18 06:40:07 +08:00
|
|
|
int i, irq = -1;
|
|
|
|
|
2012-07-18 14:06:54 +08:00
|
|
|
/*
|
|
|
|
* If MSI cannot be used for PCIe PME or hotplug, we have to use
|
|
|
|
* INTx or other interrupts, e.g. system shared interrupt.
|
|
|
|
*/
|
2012-02-03 00:09:22 +08:00
|
|
|
if (((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) ||
|
|
|
|
((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())) {
|
2012-07-18 14:06:54 +08:00
|
|
|
if (dev->irq)
|
2010-02-18 06:40:07 +08:00
|
|
|
irq = dev->irq;
|
|
|
|
goto no_msi;
|
|
|
|
}
|
2009-01-13 21:39:39 +08:00
|
|
|
|
2009-01-24 07:23:22 +08:00
|
|
|
/* Try to use MSI-X if supported */
|
2009-11-25 20:04:00 +08:00
|
|
|
if (!pcie_port_enable_msix(dev, irqs, mask))
|
|
|
|
return 0;
|
2010-02-18 06:40:07 +08:00
|
|
|
|
2012-07-18 14:06:54 +08:00
|
|
|
/*
|
|
|
|
* We're not going to use MSI-X, so try MSI and fall back to INTx.
|
|
|
|
* If neither MSI/MSI-X nor INTx available, try other interrupt. On
|
|
|
|
* some platforms, root port doesn't support MSI/MSI-X/INTx in RC mode.
|
|
|
|
*/
|
|
|
|
if (!pci_enable_msi(dev) || dev->irq)
|
2009-11-25 20:04:00 +08:00
|
|
|
irq = dev->irq;
|
2009-01-24 07:23:22 +08:00
|
|
|
|
2010-02-18 06:40:07 +08:00
|
|
|
no_msi:
|
2009-01-24 07:23:22 +08:00
|
|
|
for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
|
2009-11-25 20:04:00 +08:00
|
|
|
irqs[i] = irq;
|
|
|
|
irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-11-25 20:04:00 +08:00
|
|
|
if (irq < 0)
|
|
|
|
return -ENODEV;
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-11-25 20:05:01 +08:00
|
|
|
static void cleanup_service_irqs(struct pci_dev *dev)
|
|
|
|
{
|
|
|
|
if (dev->msix_enabled)
|
|
|
|
pci_disable_msix(dev);
|
|
|
|
else if (dev->msi_enabled)
|
|
|
|
pci_disable_msi(dev);
|
|
|
|
}
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* get_port_device_capability - discover capabilities of a PCI Express port
|
|
|
|
* @dev: PCI Express port to examine
|
|
|
|
*
|
|
|
|
* The capabilities are read from the port's PCI Express configuration registers
|
|
|
|
* as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
|
|
|
|
* 7.9 - 7.11.
|
|
|
|
*
|
|
|
|
* Return value: Bitmask of discovered port capabilities
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
static int get_port_device_capability(struct pci_dev *dev)
|
|
|
|
{
|
2012-07-24 17:20:08 +08:00
|
|
|
int services = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 reg32;
|
2012-03-07 15:16:26 +08:00
|
|
|
int cap_mask = 0;
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
int err;
|
|
|
|
|
2010-12-19 22:57:16 +08:00
|
|
|
if (pcie_ports_disabled)
|
|
|
|
return 0;
|
|
|
|
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
err = pcie_port_platform_notify(dev, &cap_mask);
|
2010-12-19 22:57:16 +08:00
|
|
|
if (!pcie_ports_auto) {
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
cap_mask = PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP
|
|
|
|
| PCIE_PORT_SERVICE_VC;
|
|
|
|
if (pci_aer_available())
|
|
|
|
cap_mask |= PCIE_PORT_SERVICE_AER;
|
2010-12-19 22:57:16 +08:00
|
|
|
} else if (err) {
|
|
|
|
return 0;
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Hot-Plug Capable */
|
2012-10-31 08:51:48 +08:00
|
|
|
if ((cap_mask & PCIE_PORT_SERVICE_HP) &&
|
|
|
|
dev->pcie_flags_reg & PCI_EXP_FLAGS_SLOT) {
|
2012-07-24 17:20:08 +08:00
|
|
|
pcie_capability_read_dword(dev, PCI_EXP_SLTCAP, ®32);
|
2010-08-21 07:57:39 +08:00
|
|
|
if (reg32 & PCI_EXP_SLTCAP_HPC) {
|
2005-04-17 06:20:36 +08:00
|
|
|
services |= PCIE_PORT_SERVICE_HP;
|
2010-08-21 07:57:39 +08:00
|
|
|
/*
|
|
|
|
* Disable hot-plug interrupts in case they have been
|
|
|
|
* enabled by the BIOS and the hot-plug service driver
|
|
|
|
* is not loaded.
|
|
|
|
*/
|
2012-07-24 17:20:08 +08:00
|
|
|
pcie_capability_clear_word(dev, PCI_EXP_SLTCTL,
|
|
|
|
PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
|
2010-08-21 07:57:39 +08:00
|
|
|
}
|
2009-01-13 21:38:34 +08:00
|
|
|
}
|
|
|
|
/* AER capable */
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
if ((cap_mask & PCIE_PORT_SERVICE_AER)
|
2010-08-21 07:57:39 +08:00
|
|
|
&& pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)) {
|
2008-10-19 08:33:19 +08:00
|
|
|
services |= PCIE_PORT_SERVICE_AER;
|
2010-08-21 07:57:39 +08:00
|
|
|
/*
|
|
|
|
* Disable AER on this port in case it's been enabled by the
|
|
|
|
* BIOS (the AER service driver will enable it when necessary).
|
|
|
|
*/
|
|
|
|
pci_disable_pcie_error_reporting(dev);
|
|
|
|
}
|
2009-01-13 21:38:34 +08:00
|
|
|
/* VC support */
|
2008-10-19 08:33:19 +08:00
|
|
|
if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
|
|
|
|
services |= PCIE_PORT_SERVICE_VC;
|
2009-11-25 20:02:51 +08:00
|
|
|
/* Root ports are capable of generating PME too */
|
PCI: PCIe: Ask BIOS for control of all native services at once
After commit 852972acff8f10f3a15679be2059bb94916cba5d (ACPI: Disable
ASPM if the platform won't provide _OSC control for PCIe) control of
the PCIe Capability Structure is unconditionally requested by
acpi_pci_root_add(), which in principle may cause problems to
happen in two ways. First, the BIOS may refuse to give control of
the PCIe Capability Structure if it is not asked for any of the
_OSC features depending on it at the same time. Second, the BIOS may
assume that control of the _OSC features depending on the PCIe
Capability Structure will be requested in the future and may behave
incorrectly if that doesn't happen. For this reason, control of
the PCIe Capability Structure should always be requested along with
control of any other _OSC features that may depend on it (ie. PCIe
native PME, PCIe native hot-plug, PCIe AER).
Rework the PCIe port driver so that (1) it checks which native PCIe
port services can be enabled, according to the BIOS, and (2) it
requests control of all these services simultaneously. In
particular, this causes pcie_portdrv_probe() to fail if the BIOS
refuses to grant control of the PCIe Capability Structure, which
means that no native PCIe port services can be enabled for the PCIe
Root Complex the given port belongs to. If that happens, ASPM is
disabled to avoid problems with mishandling it by the part of the
PCIe hierarchy for which control of the PCIe Capability Structure
has not been received.
Make it possible to override this behavior using 'pcie_ports=native'
(use the PCIe native services regardless of the BIOS response to the
control request), or 'pcie_ports=compat' (do not use the PCIe native
services at all).
Accordingly, rework the existing PCIe port service drivers so that
they don't request control of the services directly.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2010-08-22 04:02:38 +08:00
|
|
|
if ((cap_mask & PCIE_PORT_SERVICE_PME)
|
2012-07-24 17:20:03 +08:00
|
|
|
&& pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT) {
|
2009-11-25 20:02:51 +08:00
|
|
|
services |= PCIE_PORT_SERVICE_PME;
|
2010-08-21 07:57:39 +08:00
|
|
|
/*
|
|
|
|
* Disable PME interrupt on this port in case it's been enabled
|
|
|
|
* by the BIOS (the PME service driver will enable it when
|
|
|
|
* necessary).
|
|
|
|
*/
|
|
|
|
pcie_pme_interrupt_enable(dev, false);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return services;
|
|
|
|
}
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
2009-11-25 20:01:28 +08:00
|
|
|
* pcie_device_init - allocate and initialize PCI Express port service device
|
|
|
|
* @pdev: PCI Express port to associate the service device with
|
|
|
|
* @service: Type of service to associate with the service device
|
2009-01-02 02:48:55 +08:00
|
|
|
* @irq: Interrupt vector to associate with the service device
|
|
|
|
*/
|
2009-11-25 20:01:28 +08:00
|
|
|
static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-11-25 20:01:28 +08:00
|
|
|
int retval;
|
|
|
|
struct pcie_device *pcie;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct device *device;
|
|
|
|
|
2009-11-25 20:01:28 +08:00
|
|
|
pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
|
|
|
|
if (!pcie)
|
|
|
|
return -ENOMEM;
|
|
|
|
pcie->port = pdev;
|
|
|
|
pcie->irq = irq;
|
|
|
|
pcie->service = service;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Initialize generic device interface */
|
2009-11-25 20:01:28 +08:00
|
|
|
device = &pcie->device;
|
2005-04-17 06:20:36 +08:00
|
|
|
device->bus = &pcie_port_bus_type;
|
|
|
|
device->release = release_pcie_device; /* callback to free pcie dev */
|
2008-10-30 09:17:49 +08:00
|
|
|
dev_set_name(device, "%s:pcie%02x",
|
2009-11-25 20:01:28 +08:00
|
|
|
pci_name(pdev),
|
2012-07-24 17:20:03 +08:00
|
|
|
get_descriptor_id(pci_pcie_type(pdev), service));
|
2009-11-25 20:01:28 +08:00
|
|
|
device->parent = &pdev->dev;
|
2010-02-09 02:16:33 +08:00
|
|
|
device_enable_async_suspend(device);
|
2009-11-25 20:01:28 +08:00
|
|
|
|
|
|
|
retval = device_register(device);
|
|
|
|
if (retval)
|
|
|
|
kfree(pcie);
|
|
|
|
else
|
|
|
|
get_device(device);
|
|
|
|
return retval;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_device_register - register PCI Express port
|
|
|
|
* @dev: PCI Express port to register
|
|
|
|
*
|
|
|
|
* Allocate the port extension structure and register services associated with
|
|
|
|
* the port.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
int pcie_port_device_register(struct pci_dev *dev)
|
|
|
|
{
|
2009-11-25 20:05:35 +08:00
|
|
|
int status, capabilities, i, nr_service;
|
2009-11-25 20:04:00 +08:00
|
|
|
int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-11-25 20:04:30 +08:00
|
|
|
/* Enable PCI Express port device */
|
|
|
|
status = pci_enable_device(dev);
|
|
|
|
if (status)
|
2009-11-25 20:06:15 +08:00
|
|
|
return status;
|
2010-12-19 22:57:16 +08:00
|
|
|
|
|
|
|
/* Get and check PCI Express port services */
|
|
|
|
capabilities = get_port_device_capability(dev);
|
2011-03-21 11:29:20 +08:00
|
|
|
if (!capabilities)
|
2010-12-19 22:57:16 +08:00
|
|
|
return 0;
|
|
|
|
|
2009-11-25 20:04:30 +08:00
|
|
|
pci_set_master(dev);
|
2009-11-25 20:04:00 +08:00
|
|
|
/*
|
|
|
|
* Initialize service irqs. Don't use service devices that
|
|
|
|
* require interrupts if there is no way to generate them.
|
|
|
|
*/
|
|
|
|
status = init_service_irqs(dev, irqs, capabilities);
|
|
|
|
if (status) {
|
|
|
|
capabilities &= PCIE_PORT_SERVICE_VC;
|
|
|
|
if (!capabilities)
|
2009-11-25 20:04:30 +08:00
|
|
|
goto error_disable;
|
2009-01-13 21:42:01 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Allocate child services if any */
|
2009-11-25 20:05:35 +08:00
|
|
|
status = -ENODEV;
|
|
|
|
nr_service = 0;
|
|
|
|
for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
|
2009-01-13 21:39:39 +08:00
|
|
|
int service = 1 << i;
|
|
|
|
if (!(capabilities & service))
|
|
|
|
continue;
|
2009-11-25 20:05:35 +08:00
|
|
|
if (!pcie_device_init(dev, service, irqs[i]))
|
|
|
|
nr_service++;
|
2009-01-13 21:42:01 +08:00
|
|
|
}
|
2009-11-25 20:05:35 +08:00
|
|
|
if (!nr_service)
|
2009-11-25 20:05:01 +08:00
|
|
|
goto error_cleanup_irqs;
|
2009-11-25 20:05:35 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
2009-01-13 21:42:01 +08:00
|
|
|
|
2009-11-25 20:05:01 +08:00
|
|
|
error_cleanup_irqs:
|
|
|
|
cleanup_service_irqs(dev);
|
2009-11-25 20:04:30 +08:00
|
|
|
error_disable:
|
|
|
|
pci_disable_device(dev);
|
2009-01-13 21:42:01 +08:00
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2005-03-30 05:36:43 +08:00
|
|
|
static int suspend_iter(struct device *dev, void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct pcie_port_service_driver *service_driver;
|
2005-03-30 05:36:43 +08:00
|
|
|
|
2009-12-15 10:38:04 +08:00
|
|
|
if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
|
|
|
|
service_driver = to_service_driver(dev->driver);
|
|
|
|
if (service_driver->suspend)
|
|
|
|
service_driver->suspend(to_pcie_device(dev));
|
|
|
|
}
|
2005-03-30 05:36:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_device_suspend - suspend port services associated with a PCIe port
|
|
|
|
* @dev: PCI Express port to handle
|
|
|
|
*/
|
2009-02-16 05:32:48 +08:00
|
|
|
int pcie_port_device_suspend(struct device *dev)
|
2005-03-30 05:36:43 +08:00
|
|
|
{
|
2009-02-16 05:32:48 +08:00
|
|
|
return device_for_each_child(dev, NULL, suspend_iter);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-03-30 05:36:43 +08:00
|
|
|
static int resume_iter(struct device *dev, void *data)
|
|
|
|
{
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pcie_port_service_driver *service_driver;
|
|
|
|
|
2005-03-30 05:36:43 +08:00
|
|
|
if ((dev->bus == &pcie_port_bus_type) &&
|
|
|
|
(dev->driver)) {
|
|
|
|
service_driver = to_service_driver(dev->driver);
|
|
|
|
if (service_driver->resume)
|
|
|
|
service_driver->resume(to_pcie_device(dev));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-03-30 05:36:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_device_suspend - resume port services associated with a PCIe port
|
|
|
|
* @dev: PCI Express port to handle
|
|
|
|
*/
|
2009-02-16 05:32:48 +08:00
|
|
|
int pcie_port_device_resume(struct device *dev)
|
2005-03-30 05:36:43 +08:00
|
|
|
{
|
2009-02-16 05:32:48 +08:00
|
|
|
return device_for_each_child(dev, NULL, resume_iter);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-02-16 05:32:48 +08:00
|
|
|
#endif /* PM */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-03-30 05:36:43 +08:00
|
|
|
static int remove_iter(struct device *dev, void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-03-30 05:36:43 +08:00
|
|
|
if (dev->bus == &pcie_port_bus_type) {
|
2009-02-21 12:16:07 +08:00
|
|
|
put_device(dev);
|
|
|
|
device_unregister(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-03-30 05:36:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-02 02:48:55 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_device_remove - unregister PCI Express port service devices
|
|
|
|
* @dev: PCI Express port the service devices to unregister are associated with
|
|
|
|
*
|
|
|
|
* Remove PCI Express port service devices associated with given port and
|
|
|
|
* disable MSI-X or MSI for the port.
|
|
|
|
*/
|
2005-03-30 05:36:43 +08:00
|
|
|
void pcie_port_device_remove(struct pci_dev *dev)
|
|
|
|
{
|
2009-02-21 12:16:07 +08:00
|
|
|
device_for_each_child(&dev->dev, NULL, remove_iter);
|
2009-11-25 20:05:01 +08:00
|
|
|
cleanup_service_irqs(dev);
|
2009-11-25 20:04:00 +08:00
|
|
|
pci_disable_device(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-02 02:53:32 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_probe_service - probe driver for given PCI Express port service
|
|
|
|
* @dev: PCI Express port service device to probe against
|
|
|
|
*
|
|
|
|
* If PCI Express port service driver is registered with
|
|
|
|
* pcie_port_service_register(), this function will be called by the driver core
|
|
|
|
* whenever match is found between the driver and a port service device.
|
|
|
|
*/
|
2009-01-02 02:52:12 +08:00
|
|
|
static int pcie_port_probe_service(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-01-02 02:52:12 +08:00
|
|
|
struct pcie_device *pciedev;
|
|
|
|
struct pcie_port_service_driver *driver;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (!dev || !dev->driver)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
driver = to_service_driver(dev->driver);
|
|
|
|
if (!driver || !driver->probe)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pciedev = to_pcie_device(dev);
|
2009-01-13 21:44:19 +08:00
|
|
|
status = driver->probe(pciedev);
|
2009-01-02 02:52:12 +08:00
|
|
|
if (!status) {
|
|
|
|
dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
|
|
|
|
driver->name);
|
|
|
|
get_device(dev);
|
|
|
|
}
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-02 02:53:32 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_remove_service - detach driver from given PCI Express port service
|
|
|
|
* @dev: PCI Express port service device to handle
|
|
|
|
*
|
|
|
|
* If PCI Express port service driver is registered with
|
|
|
|
* pcie_port_service_register(), this function will be called by the driver core
|
|
|
|
* when device_unregister() is called for the port service device associated
|
|
|
|
* with the driver.
|
|
|
|
*/
|
2009-01-02 02:52:12 +08:00
|
|
|
static int pcie_port_remove_service(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-01-02 02:52:12 +08:00
|
|
|
struct pcie_device *pciedev;
|
|
|
|
struct pcie_port_service_driver *driver;
|
|
|
|
|
|
|
|
if (!dev || !dev->driver)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pciedev = to_pcie_device(dev);
|
|
|
|
driver = to_service_driver(dev->driver);
|
|
|
|
if (driver && driver->remove) {
|
|
|
|
dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
|
|
|
|
driver->name);
|
|
|
|
driver->remove(pciedev);
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-02 02:53:32 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_shutdown_service - shut down given PCI Express port service
|
|
|
|
* @dev: PCI Express port service device to handle
|
|
|
|
*
|
|
|
|
* If PCI Express port service driver is registered with
|
|
|
|
* pcie_port_service_register(), this function will be called by the driver core
|
|
|
|
* when device_shutdown() is called for the port service device associated
|
|
|
|
* with the driver.
|
|
|
|
*/
|
2009-01-02 02:52:12 +08:00
|
|
|
static void pcie_port_shutdown_service(struct device *dev) {}
|
|
|
|
|
2009-01-02 02:53:32 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_service_register - register PCI Express port service driver
|
|
|
|
* @new: PCI Express port service driver to register
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
int pcie_port_service_register(struct pcie_port_service_driver *new)
|
|
|
|
{
|
2010-08-21 07:51:44 +08:00
|
|
|
if (pcie_ports_disabled)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
new->driver.name = (char *)new->name;
|
|
|
|
new->driver.bus = &pcie_port_bus_type;
|
|
|
|
new->driver.probe = pcie_port_probe_service;
|
|
|
|
new->driver.remove = pcie_port_remove_service;
|
|
|
|
new->driver.shutdown = pcie_port_shutdown_service;
|
|
|
|
|
|
|
|
return driver_register(&new->driver);
|
2005-03-30 05:36:43 +08:00
|
|
|
}
|
2009-12-15 10:38:04 +08:00
|
|
|
EXPORT_SYMBOL(pcie_port_service_register);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-01-02 02:53:32 +08:00
|
|
|
/**
|
|
|
|
* pcie_port_service_unregister - unregister PCI Express port service driver
|
|
|
|
* @drv: PCI Express port service driver to unregister
|
|
|
|
*/
|
2009-01-02 02:52:12 +08:00
|
|
|
void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-01-02 02:52:12 +08:00
|
|
|
driver_unregister(&drv->driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(pcie_port_service_unregister);
|