2009-08-25 20:07:11 +00:00
|
|
|
/*
|
|
|
|
* Helper routines to scan the device tree for PCI devices and busses
|
|
|
|
*
|
|
|
|
* Migrated out of PowerPC architecture pci_64.c file by Grant Likely
|
|
|
|
* <grant.likely@secretlab.ca> so that these routines are available for
|
|
|
|
* 32 bit also.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
|
|
|
|
* Rework, based on alpha PCI code.
|
|
|
|
* Copyright (c) 2009 Secret Lab Technologies Ltd.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* version 2 as published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/pci.h>
|
2011-05-27 14:46:24 +00:00
|
|
|
#include <linux/export.h>
|
2009-08-25 20:07:11 +00:00
|
|
|
#include <asm/pci-bridge.h>
|
|
|
|
#include <asm/prom.h>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_int_prop - Decode a u32 from a device tree property
|
|
|
|
*/
|
|
|
|
static u32 get_int_prop(struct device_node *np, const char *name, u32 def)
|
|
|
|
{
|
2013-08-06 16:01:41 +00:00
|
|
|
const __be32 *prop;
|
2009-08-25 20:07:11 +00:00
|
|
|
int len;
|
|
|
|
|
|
|
|
prop = of_get_property(np, name, &len);
|
|
|
|
if (prop && len >= 4)
|
2013-08-06 16:01:41 +00:00
|
|
|
return of_read_number(prop, 1);
|
2009-08-25 20:07:11 +00:00
|
|
|
return def;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pci_parse_of_flags - Parse the flags cell of a device tree PCI address
|
|
|
|
* @addr0: value of 1st cell of a device tree PCI address.
|
|
|
|
* @bridge: Set this flag if the address is from a bridge 'ranges' property
|
|
|
|
*/
|
2014-08-19 22:55:18 +00:00
|
|
|
static unsigned int pci_parse_of_flags(u32 addr0, int bridge)
|
2009-08-25 20:07:11 +00:00
|
|
|
{
|
|
|
|
unsigned int flags = 0;
|
|
|
|
|
|
|
|
if (addr0 & 0x02000000) {
|
|
|
|
flags = IORESOURCE_MEM | PCI_BASE_ADDRESS_SPACE_MEMORY;
|
|
|
|
flags |= (addr0 >> 22) & PCI_BASE_ADDRESS_MEM_TYPE_64;
|
|
|
|
flags |= (addr0 >> 28) & PCI_BASE_ADDRESS_MEM_TYPE_1M;
|
|
|
|
if (addr0 & 0x40000000)
|
|
|
|
flags |= IORESOURCE_PREFETCH
|
|
|
|
| PCI_BASE_ADDRESS_MEM_PREFETCH;
|
|
|
|
/* Note: We don't know whether the ROM has been left enabled
|
|
|
|
* by the firmware or not. We mark it as disabled (ie, we do
|
|
|
|
* not set the IORESOURCE_ROM_ENABLE flag) for now rather than
|
|
|
|
* do a config space read, it will be force-enabled if needed
|
|
|
|
*/
|
|
|
|
if (!bridge && (addr0 & 0xff) == 0x30)
|
|
|
|
flags |= IORESOURCE_READONLY;
|
|
|
|
} else if (addr0 & 0x01000000)
|
|
|
|
flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
|
|
|
|
if (flags)
|
|
|
|
flags |= IORESOURCE_SIZEALIGN;
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_pci_parse_addrs - Parse PCI addresses assigned in the device tree node
|
|
|
|
* @node: device tree node for the PCI device
|
|
|
|
* @dev: pci_dev structure for the device
|
|
|
|
*
|
|
|
|
* This function parses the 'assigned-addresses' property of a PCI devices'
|
|
|
|
* device tree node and writes them into the associated pci_dev structure.
|
|
|
|
*/
|
|
|
|
static void of_pci_parse_addrs(struct device_node *node, struct pci_dev *dev)
|
|
|
|
{
|
|
|
|
u64 base, size;
|
|
|
|
unsigned int flags;
|
2012-03-16 23:48:14 +00:00
|
|
|
struct pci_bus_region region;
|
2009-08-25 20:07:11 +00:00
|
|
|
struct resource *res;
|
2013-08-06 16:01:41 +00:00
|
|
|
const __be32 *addrs;
|
2009-08-25 20:07:11 +00:00
|
|
|
u32 i;
|
|
|
|
int proplen;
|
|
|
|
|
|
|
|
addrs = of_get_property(node, "assigned-addresses", &proplen);
|
|
|
|
if (!addrs)
|
|
|
|
return;
|
|
|
|
pr_debug(" parse addresses (%d bytes) @ %p\n", proplen, addrs);
|
|
|
|
for (; proplen >= 20; proplen -= 20, addrs += 5) {
|
2013-08-06 16:01:41 +00:00
|
|
|
flags = pci_parse_of_flags(of_read_number(addrs, 1), 0);
|
2009-08-25 20:07:11 +00:00
|
|
|
if (!flags)
|
|
|
|
continue;
|
|
|
|
base = of_read_number(&addrs[1], 2);
|
|
|
|
size = of_read_number(&addrs[3], 2);
|
|
|
|
if (!size)
|
|
|
|
continue;
|
2013-08-06 16:01:41 +00:00
|
|
|
i = of_read_number(addrs, 1) & 0xff;
|
2009-08-25 20:07:11 +00:00
|
|
|
pr_debug(" base: %llx, size: %llx, i: %x\n",
|
|
|
|
(unsigned long long)base,
|
|
|
|
(unsigned long long)size, i);
|
|
|
|
|
|
|
|
if (PCI_BASE_ADDRESS_0 <= i && i <= PCI_BASE_ADDRESS_5) {
|
|
|
|
res = &dev->resource[(i - PCI_BASE_ADDRESS_0) >> 2];
|
|
|
|
} else if (i == dev->rom_base_reg) {
|
|
|
|
res = &dev->resource[PCI_ROM_RESOURCE];
|
2015-08-11 03:07:06 +00:00
|
|
|
flags |= IORESOURCE_READONLY;
|
2009-08-25 20:07:11 +00:00
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "PCI: bad cfg reg num 0x%x\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
res->flags = flags;
|
|
|
|
res->name = pci_name(dev);
|
2012-03-16 23:48:14 +00:00
|
|
|
region.start = base;
|
|
|
|
region.end = base + size - 1;
|
PCI: Convert pcibios_resource_to_bus() to take a pci_bus, not a pci_dev
These interfaces:
pcibios_resource_to_bus(struct pci_dev *dev, *bus_region, *resource)
pcibios_bus_to_resource(struct pci_dev *dev, *resource, *bus_region)
took a pci_dev, but they really depend only on the pci_bus. And we want to
use them in resource allocation paths where we have the bus but not a
device, so this patch converts them to take the pci_bus instead of the
pci_dev:
pcibios_resource_to_bus(struct pci_bus *bus, *bus_region, *resource)
pcibios_bus_to_resource(struct pci_bus *bus, *resource, *bus_region)
In fact, with standard PCI-PCI bridges, they only depend on the host
bridge, because that's the only place address translation occurs, but
we aren't going that far yet.
[bhelgaas: changelog]
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2013-12-10 06:54:40 +00:00
|
|
|
pcibios_bus_to_resource(dev->bus, res, ®ion);
|
2009-08-25 20:07:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_create_pci_dev - Given a device tree node on a pci bus, create a pci_dev
|
|
|
|
* @node: device tree node pointer
|
|
|
|
* @bus: bus the device is sitting on
|
|
|
|
* @devfn: PCI function number, extracted from device tree by caller.
|
|
|
|
*/
|
|
|
|
struct pci_dev *of_create_pci_dev(struct device_node *node,
|
|
|
|
struct pci_bus *bus, int devfn)
|
|
|
|
{
|
|
|
|
struct pci_dev *dev;
|
|
|
|
const char *type;
|
|
|
|
|
2013-05-25 13:48:31 +00:00
|
|
|
dev = pci_alloc_dev(bus);
|
2009-08-25 20:07:11 +00:00
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
type = of_get_property(node, "device_type", NULL);
|
|
|
|
if (type == NULL)
|
|
|
|
type = "";
|
|
|
|
|
|
|
|
pr_debug(" create device, devfn: %x, type: %s\n", devfn, type);
|
|
|
|
|
2011-02-04 18:24:11 +00:00
|
|
|
dev->dev.of_node = of_node_get(node);
|
2009-08-25 20:07:11 +00:00
|
|
|
dev->dev.parent = bus->bridge;
|
|
|
|
dev->dev.bus = &pci_bus_type;
|
|
|
|
dev->devfn = devfn;
|
|
|
|
dev->multifunction = 0; /* maybe a lie? */
|
2009-09-16 14:49:54 +00:00
|
|
|
dev->needs_freset = 0; /* pcie fundamental reset required */
|
2010-01-26 17:10:03 +00:00
|
|
|
set_pcie_port_type(dev);
|
2009-08-25 20:07:11 +00:00
|
|
|
|
2015-07-17 09:16:32 +00:00
|
|
|
pci_dev_assign_slot(dev);
|
2009-08-25 20:07:11 +00:00
|
|
|
dev->vendor = get_int_prop(node, "vendor-id", 0xffff);
|
|
|
|
dev->device = get_int_prop(node, "device-id", 0xffff);
|
|
|
|
dev->subsystem_vendor = get_int_prop(node, "subsystem-vendor-id", 0);
|
|
|
|
dev->subsystem_device = get_int_prop(node, "subsystem-id", 0);
|
|
|
|
|
|
|
|
dev->cfg_size = pci_cfg_space_size(dev);
|
|
|
|
|
|
|
|
dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(bus),
|
|
|
|
dev->bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn));
|
|
|
|
dev->class = get_int_prop(node, "class-code", 0);
|
|
|
|
dev->revision = get_int_prop(node, "revision-id", 0);
|
|
|
|
|
|
|
|
pr_debug(" class: 0x%x\n", dev->class);
|
|
|
|
pr_debug(" revision: 0x%x\n", dev->revision);
|
|
|
|
|
2013-05-17 21:08:50 +00:00
|
|
|
dev->current_state = PCI_UNKNOWN; /* unknown power state */
|
2009-08-25 20:07:11 +00:00
|
|
|
dev->error_state = pci_channel_io_normal;
|
|
|
|
dev->dma_mask = 0xffffffff;
|
|
|
|
|
2010-01-26 17:10:05 +00:00
|
|
|
/* Early fixups, before probing the BARs */
|
|
|
|
pci_fixup_device(pci_fixup_early, dev);
|
|
|
|
|
2009-08-25 20:07:11 +00:00
|
|
|
if (!strcmp(type, "pci") || !strcmp(type, "pciex")) {
|
|
|
|
/* a PCI-PCI bridge */
|
|
|
|
dev->hdr_type = PCI_HEADER_TYPE_BRIDGE;
|
|
|
|
dev->rom_base_reg = PCI_ROM_ADDRESS1;
|
2010-01-26 17:10:03 +00:00
|
|
|
set_pcie_hotplug_bridge(dev);
|
2009-08-25 20:07:11 +00:00
|
|
|
} else if (!strcmp(type, "cardbus")) {
|
|
|
|
dev->hdr_type = PCI_HEADER_TYPE_CARDBUS;
|
|
|
|
} else {
|
|
|
|
dev->hdr_type = PCI_HEADER_TYPE_NORMAL;
|
|
|
|
dev->rom_base_reg = PCI_ROM_ADDRESS;
|
|
|
|
/* Maybe do a default OF mapping here */
|
|
|
|
dev->irq = NO_IRQ;
|
|
|
|
}
|
|
|
|
|
|
|
|
of_pci_parse_addrs(node, dev);
|
|
|
|
|
|
|
|
pr_debug(" adding to system ...\n");
|
|
|
|
|
|
|
|
pci_device_add(dev, bus);
|
|
|
|
|
2015-08-24 12:42:47 +00:00
|
|
|
/* Setup MSI caps & disable MSI/MSI-X interrupts */
|
|
|
|
pci_msi_setup_pci_dev(dev);
|
|
|
|
|
2009-08-25 20:07:11 +00:00
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_create_pci_dev);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_scan_pci_bridge - Set up a PCI bridge and scan for child nodes
|
|
|
|
* @dev: pci_dev structure for the bridge
|
|
|
|
*
|
|
|
|
* of_scan_bus() calls this routine for each PCI bridge that it finds, and
|
|
|
|
* this routine in turn call of_scan_bus() recusively to scan for more child
|
|
|
|
* devices.
|
|
|
|
*/
|
2012-12-21 22:04:10 +00:00
|
|
|
void of_scan_pci_bridge(struct pci_dev *dev)
|
2009-08-25 20:07:11 +00:00
|
|
|
{
|
2011-04-11 01:37:07 +00:00
|
|
|
struct device_node *node = dev->dev.of_node;
|
2009-08-25 20:07:11 +00:00
|
|
|
struct pci_bus *bus;
|
2015-03-31 05:00:56 +00:00
|
|
|
struct pci_controller *phb;
|
2013-08-06 16:01:41 +00:00
|
|
|
const __be32 *busrange, *ranges;
|
2009-08-25 20:07:11 +00:00
|
|
|
int len, i, mode;
|
2012-03-16 23:48:14 +00:00
|
|
|
struct pci_bus_region region;
|
2009-08-25 20:07:11 +00:00
|
|
|
struct resource *res;
|
|
|
|
unsigned int flags;
|
|
|
|
u64 size;
|
|
|
|
|
|
|
|
pr_debug("of_scan_pci_bridge(%s)\n", node->full_name);
|
|
|
|
|
|
|
|
/* parse bus-range property */
|
|
|
|
busrange = of_get_property(node, "bus-range", &len);
|
|
|
|
if (busrange == NULL || len != 8) {
|
|
|
|
printk(KERN_DEBUG "Can't get bus-range for PCI-PCI bridge %s\n",
|
|
|
|
node->full_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ranges = of_get_property(node, "ranges", &len);
|
|
|
|
if (ranges == NULL) {
|
|
|
|
printk(KERN_DEBUG "Can't get ranges for PCI-PCI bridge %s\n",
|
|
|
|
node->full_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-06 16:01:41 +00:00
|
|
|
bus = pci_find_bus(pci_domain_nr(dev->bus),
|
|
|
|
of_read_number(busrange, 1));
|
2009-08-25 20:07:11 +00:00
|
|
|
if (!bus) {
|
2013-08-06 16:01:41 +00:00
|
|
|
bus = pci_add_new_bus(dev->bus, dev,
|
|
|
|
of_read_number(busrange, 1));
|
2013-07-24 02:24:57 +00:00
|
|
|
if (!bus) {
|
|
|
|
printk(KERN_ERR "Failed to create pci bus for %s\n",
|
|
|
|
node->full_name);
|
|
|
|
return;
|
|
|
|
}
|
2009-08-25 20:07:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bus->primary = dev->bus->number;
|
2013-08-06 16:01:41 +00:00
|
|
|
pci_bus_insert_busn_res(bus, of_read_number(busrange, 1),
|
|
|
|
of_read_number(busrange+1, 1));
|
2009-08-25 20:07:11 +00:00
|
|
|
bus->bridge_ctl = 0;
|
|
|
|
|
|
|
|
/* parse ranges property */
|
|
|
|
/* PCI #address-cells == 3 and #size-cells == 2 always */
|
|
|
|
res = &dev->resource[PCI_BRIDGE_RESOURCES];
|
|
|
|
for (i = 0; i < PCI_NUM_RESOURCES - PCI_BRIDGE_RESOURCES; ++i) {
|
|
|
|
res->flags = 0;
|
|
|
|
bus->resource[i] = res;
|
|
|
|
++res;
|
|
|
|
}
|
|
|
|
i = 1;
|
|
|
|
for (; len >= 32; len -= 32, ranges += 8) {
|
2013-08-06 16:01:41 +00:00
|
|
|
flags = pci_parse_of_flags(of_read_number(ranges, 1), 1);
|
2009-08-25 20:07:11 +00:00
|
|
|
size = of_read_number(&ranges[6], 2);
|
|
|
|
if (flags == 0 || size == 0)
|
|
|
|
continue;
|
|
|
|
if (flags & IORESOURCE_IO) {
|
|
|
|
res = bus->resource[0];
|
|
|
|
if (res->flags) {
|
|
|
|
printk(KERN_ERR "PCI: ignoring extra I/O range"
|
|
|
|
" for bridge %s\n", node->full_name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (i >= PCI_NUM_RESOURCES - PCI_BRIDGE_RESOURCES) {
|
|
|
|
printk(KERN_ERR "PCI: too many memory ranges"
|
|
|
|
" for bridge %s\n", node->full_name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
res = bus->resource[i];
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
res->flags = flags;
|
2012-03-16 23:48:14 +00:00
|
|
|
region.start = of_read_number(&ranges[1], 2);
|
|
|
|
region.end = region.start + size - 1;
|
PCI: Convert pcibios_resource_to_bus() to take a pci_bus, not a pci_dev
These interfaces:
pcibios_resource_to_bus(struct pci_dev *dev, *bus_region, *resource)
pcibios_bus_to_resource(struct pci_dev *dev, *resource, *bus_region)
took a pci_dev, but they really depend only on the pci_bus. And we want to
use them in resource allocation paths where we have the bus but not a
device, so this patch converts them to take the pci_bus instead of the
pci_dev:
pcibios_resource_to_bus(struct pci_bus *bus, *bus_region, *resource)
pcibios_bus_to_resource(struct pci_bus *bus, *resource, *bus_region)
In fact, with standard PCI-PCI bridges, they only depend on the host
bridge, because that's the only place address translation occurs, but
we aren't going that far yet.
[bhelgaas: changelog]
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2013-12-10 06:54:40 +00:00
|
|
|
pcibios_bus_to_resource(dev->bus, res, ®ion);
|
2009-08-25 20:07:11 +00:00
|
|
|
}
|
|
|
|
sprintf(bus->name, "PCI Bus %04x:%02x", pci_domain_nr(bus),
|
|
|
|
bus->number);
|
|
|
|
pr_debug(" bus name: %s\n", bus->name);
|
|
|
|
|
2015-03-31 05:00:56 +00:00
|
|
|
phb = pci_bus_to_host(bus);
|
|
|
|
|
2009-08-25 20:07:11 +00:00
|
|
|
mode = PCI_PROBE_NORMAL;
|
2015-03-31 05:00:56 +00:00
|
|
|
if (phb->controller_ops.probe_mode)
|
|
|
|
mode = phb->controller_ops.probe_mode(bus);
|
2009-08-25 20:07:11 +00:00
|
|
|
pr_debug(" probe mode: %d\n", mode);
|
|
|
|
|
|
|
|
if (mode == PCI_PROBE_DEVTREE)
|
|
|
|
of_scan_bus(node, bus);
|
|
|
|
else if (mode == PCI_PROBE_NORMAL)
|
|
|
|
pci_scan_child_bus(bus);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_scan_pci_bridge);
|
|
|
|
|
2013-07-24 02:24:57 +00:00
|
|
|
static struct pci_dev *of_scan_pci_dev(struct pci_bus *bus,
|
|
|
|
struct device_node *dn)
|
|
|
|
{
|
|
|
|
struct pci_dev *dev = NULL;
|
2013-10-17 12:19:43 +00:00
|
|
|
const __be32 *reg;
|
2013-07-24 02:24:57 +00:00
|
|
|
int reglen, devfn;
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 08:00:19 +00:00
|
|
|
#ifdef CONFIG_EEH
|
2015-03-17 05:15:08 +00:00
|
|
|
struct eeh_dev *edev = pdn_to_eeh_dev(PCI_DN(dn));
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 08:00:19 +00:00
|
|
|
#endif
|
2013-07-24 02:24:57 +00:00
|
|
|
|
|
|
|
pr_debug(" * %s\n", dn->full_name);
|
|
|
|
if (!of_device_is_available(dn))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
reg = of_get_property(dn, "reg", ®len);
|
|
|
|
if (reg == NULL || reglen < 20)
|
|
|
|
return NULL;
|
2013-10-17 12:19:43 +00:00
|
|
|
devfn = (of_read_number(reg, 1) >> 8) & 0xff;
|
2013-07-24 02:24:57 +00:00
|
|
|
|
|
|
|
/* Check if the PCI device is already there */
|
|
|
|
dev = pci_get_slot(bus, devfn);
|
|
|
|
if (dev) {
|
|
|
|
pci_dev_put(dev);
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 08:00:19 +00:00
|
|
|
/* Device removed permanently ? */
|
|
|
|
#ifdef CONFIG_EEH
|
|
|
|
if (edev && (edev->mode & EEH_DEV_REMOVED))
|
|
|
|
return NULL;
|
|
|
|
#endif
|
|
|
|
|
2013-07-24 02:24:57 +00:00
|
|
|
/* create a new pci_dev for this device */
|
|
|
|
dev = of_create_pci_dev(dn, bus, devfn);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pr_debug(" dev header type: %x\n", dev->hdr_type);
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
2009-08-25 20:07:11 +00:00
|
|
|
/**
|
|
|
|
* __of_scan_bus - given a PCI bus node, setup bus and scan for child devices
|
|
|
|
* @node: device tree node for the PCI bus
|
|
|
|
* @bus: pci_bus structure for the PCI bus
|
|
|
|
* @rescan_existing: Flag indicating bus has already been set up
|
|
|
|
*/
|
2012-12-21 22:04:10 +00:00
|
|
|
static void __of_scan_bus(struct device_node *node, struct pci_bus *bus,
|
|
|
|
int rescan_existing)
|
2009-08-25 20:07:11 +00:00
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
struct pci_dev *dev;
|
|
|
|
|
2010-02-06 07:47:20 +00:00
|
|
|
pr_debug("of_scan_bus(%s) bus no %d...\n",
|
2009-08-25 20:07:11 +00:00
|
|
|
node->full_name, bus->number);
|
|
|
|
|
|
|
|
/* Scan direct children */
|
|
|
|
for_each_child_of_node(node, child) {
|
2013-07-24 02:24:57 +00:00
|
|
|
dev = of_scan_pci_dev(bus, child);
|
2009-08-25 20:07:11 +00:00
|
|
|
if (!dev)
|
|
|
|
continue;
|
|
|
|
pr_debug(" dev header type: %x\n", dev->hdr_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Apply all fixups necessary. We don't fixup the bus "self"
|
|
|
|
* for an existing bridge that is being rescanned
|
|
|
|
*/
|
|
|
|
if (!rescan_existing)
|
|
|
|
pcibios_setup_bus_self(bus);
|
|
|
|
pcibios_setup_bus_devices(bus);
|
|
|
|
|
|
|
|
/* Now scan child busses */
|
|
|
|
list_for_each_entry(dev, &bus->devices, bus_list) {
|
2014-05-04 04:23:41 +00:00
|
|
|
if (pci_is_bridge(dev)) {
|
2011-04-11 01:37:07 +00:00
|
|
|
of_scan_pci_bridge(dev);
|
2009-08-25 20:07:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_scan_bus - given a PCI bus node, setup bus and scan for child devices
|
|
|
|
* @node: device tree node for the PCI bus
|
|
|
|
* @bus: pci_bus structure for the PCI bus
|
|
|
|
*/
|
2012-12-21 22:04:10 +00:00
|
|
|
void of_scan_bus(struct device_node *node, struct pci_bus *bus)
|
2009-08-25 20:07:11 +00:00
|
|
|
{
|
|
|
|
__of_scan_bus(node, bus, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_scan_bus);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_rescan_bus - given a PCI bus node, scan for child devices
|
|
|
|
* @node: device tree node for the PCI bus
|
|
|
|
* @bus: pci_bus structure for the PCI bus
|
|
|
|
*
|
|
|
|
* Same as of_scan_bus, but for a pci_bus structure that has already been
|
|
|
|
* setup.
|
|
|
|
*/
|
2012-12-21 22:04:10 +00:00
|
|
|
void of_rescan_bus(struct device_node *node, struct pci_bus *bus)
|
2009-08-25 20:07:11 +00:00
|
|
|
{
|
|
|
|
__of_scan_bus(node, bus, 1);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_rescan_bus);
|
|
|
|
|