bianbu-repo-mirror/bianbu-linux-6.6
1
0
Fork 0
mirror of https://gitee.com/bianbu-linux/linux-6.6 synced 2025-04-24 14:07:52 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

ia64/PCI/ACPI: Use common interface to support PCI host bridge

Browse source 
Use common interface to simplify PCI host bridge implementation.

Tested-by: Tony Luck <tony.luck@intel.com>
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
This commit is contained in:
Jiang Liu 2015-10-14 14:29:42 +08:00 • committed by Rafael J. Wysocki
parent 4d6b4e69a2
commit 02715e86b2
1 changed files with 55 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

219
arch/ia64/pci/pci.c
View file

@ -116,15 +116,12 @@ struct pci_ops pci_root_ops = {
}; };
struct pci_root_info { struct pci_root_info {
struct acpi_pci_root_info common;
struct pci_controller controller; struct pci_controller controller;
struct acpi_device *bridge;
struct list_head resources;
struct list_head io_resources; struct list_head io_resources;
char name[16];
}; };
static unsigned int static unsigned int new_space(u64 phys_base, int sparse)
new_space (u64 phys_base, int sparse)
{ {
u64 mmio_base; u64 mmio_base;
int i; int i;
@ -160,11 +157,11 @@ static int add_io_space(struct device *dev, struct pci_root_info *info,
unsigned long base, min, max, base_port; unsigned long base, min, max, base_port;
unsigned int sparse = 0, space_nr, len; unsigned int sparse = 0, space_nr, len;
len = strlen(info->name) + 32; len = strlen(info->common.name) + 32;
iospace = resource_list_create_entry(NULL, len); iospace = resource_list_create_entry(NULL, len);
if (!iospace) { if (!iospace) {
dev_err(dev, "PCI: No memory for %s I/O port space\n", dev_err(dev, "PCI: No memory for %s I/O port space\n",
info->name); info->common.name);
return -ENOMEM; return -ENOMEM;
} }
@ -179,7 +176,7 @@ static int add_io_space(struct device *dev, struct pci_root_info *info,
max = res->end - entry->offset; max = res->end - entry->offset;
base = __pa(io_space[space_nr].mmio_base); base = __pa(io_space[space_nr].mmio_base);
base_port = IO_SPACE_BASE(space_nr); base_port = IO_SPACE_BASE(space_nr);
snprintf(name, len, "%s I/O Ports %08lx-%08lx", info->name, snprintf(name, len, "%s I/O Ports %08lx-%08lx", info->common.name,
base_port + min, base_port + max); base_port + min, base_port + max);
/* /*
@ -234,217 +231,81 @@ static bool resource_is_pcicfg_ioport(struct resource *res)
res->start == 0xCF8 && res->end == 0xCFF; res->start == 0xCF8 && res->end == 0xCFF;
} }
static int static int pci_acpi_root_prepare_resources(struct acpi_pci_root_info *ci)
probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device,
int busnum, int domain)
{ {
int ret; struct device *dev = &ci->bridge->dev;
struct list_head *list = &info->resources; struct pci_root_info *info;
struct resource *res;
struct resource_entry *entry, *tmp; struct resource_entry *entry, *tmp;
int status;
ret = acpi_dev_get_resources(device, list, status = acpi_pci_probe_root_resources(ci);
acpi_dev_filter_resource_type_cb, if (status > 0) {
(void *)(IORESOURCE_IO | IORESOURCE_MEM)); info = container_of(ci, struct pci_root_info, common);
if (ret < 0) resource_list_for_each_entry_safe(entry, tmp, &ci->resources) {
dev_warn(&device->dev,
"failed to parse _CRS method, error code %d\n", ret);
else if (ret == 0)
dev_dbg(&device->dev,
"no IO and memory resources present in _CRS\n");
else
resource_list_for_each_entry_safe(entry, tmp, list) {
if ((entry->res->flags & IORESOURCE_DISABLED) ||
resource_is_pcicfg_ioport(entry->res))
resource_list_destroy_entry(entry);
else
entry->res->name = info->name;
}
return ret;
}
static void validate_resources(struct device *dev, struct list_head *resources,
unsigned long type)
{
LIST_HEAD(list);
struct resource *res1, *res2, *root = NULL;
struct resource_entry *tmp, *entry, *entry2;
BUG_ON((type & (IORESOURCE_MEM | IORESOURCE_IO)) == 0);
root = (type & IORESOURCE_MEM) ? &iomem_resource : &ioport_resource;
list_splice_init(resources, &list);
resource_list_for_each_entry_safe(entry, tmp, &list) {
bool free = false;
resource_size_t end;
res1 = entry->res;
if (!(res1->flags & type))
goto next;
/* Exclude non-addressable range or non-addressable portion */
end = min(res1->end, root->end);
if (end <= res1->start) {
dev_info(dev, "host bridge window %pR (ignored, not CPU addressable)\n",
res1);
free = true;
goto next;
} else if (res1->end != end) {
dev_info(dev, "host bridge window %pR ([%#llx-%#llx] ignored, not CPU addressable)\n",
res1, (unsigned long long)end + 1,
(unsigned long long)res1->end);
res1->end = end;
}
resource_list_for_each_entry(entry2, resources) {
res2 = entry2->res;
if (!(res2->flags & type))
continue;
/*
* I don't like throwing away windows because then
* our resources no longer match the ACPI _CRS, but
* the kernel resource tree doesn't allow overlaps.
*/
if (resource_overlaps(res1, res2)) {
res2->start = min(res1->start, res2->start);
res2->end = max(res1->end, res2->end);
dev_info(dev, "host bridge window expanded to %pR; %pR ignored\n",
res2, res1);
free = true;
goto next;
}
}
next:
resource_list_del(entry);
if (free)
resource_list_free_entry(entry);
else
resource_list_add_tail(entry, resources);
}
}
static void add_resources(struct pci_root_info *info, struct device *dev)
{
struct resource_entry *entry, *tmp;
struct resource *res, *conflict, *root = NULL;
struct list_head *list = &info->resources;
validate_resources(dev, list, IORESOURCE_MEM);
validate_resources(dev, list, IORESOURCE_IO);
resource_list_for_each_entry_safe(entry, tmp, list) {
res = entry->res; res = entry->res;
if (res->flags & IORESOURCE_MEM) { if (res->flags & IORESOURCE_MEM) {
root = &iomem_resource;
/* /*
* HP's firmware has a hack to work around a Windows * HP's firmware has a hack to work around a
* bug. Ignore these tiny memory ranges. * Windows bug. Ignore these tiny memory ranges.
*/ */
if (resource_size(res) <= 16) { if (resource_size(res) <= 16) {
resource_list_destroy_entry(entry); resource_list_del(entry);
continue; insert_resource(&iomem_resource,
entry->res);
resource_list_add_tail(entry,
&info->io_resources);
} }
} else if (res->flags & IORESOURCE_IO) { } else if (res->flags & IORESOURCE_IO) {
root = &ioport_resource; if (resource_is_pcicfg_ioport(entry->res))
if (add_io_space(&info->bridge->dev, info, entry)) {
resource_list_destroy_entry(entry); resource_list_destroy_entry(entry);
continue; else if (add_io_space(dev, info, entry))
}
} else {
BUG_ON(res);
}
conflict = insert_resource_conflict(root, res);
if (conflict) {
dev_info(dev,
"ignoring host bridge window %pR (conflicts with %s %pR)\n",
res, conflict->name, conflict);
resource_list_destroy_entry(entry); resource_list_destroy_entry(entry);
} }
} }
} }
static void __release_pci_root_info(struct pci_root_info *info) return status;
}
static void pci_acpi_root_release_info(struct acpi_pci_root_info *ci)
{ {
struct resource *res; struct pci_root_info *info;
struct resource_entry *entry, *tentry; struct resource_entry *entry, *tmp;
resource_list_for_each_entry_safe(entry, tentry, &info->io_resources) { info = container_of(ci, struct pci_root_info, common);
resource_list_for_each_entry_safe(entry, tmp, &info->io_resources) {
release_resource(entry->res); release_resource(entry->res);
resource_list_destroy_entry(entry); resource_list_destroy_entry(entry);
} }
resource_list_for_each_entry_safe(entry, tentry, &info->resources) {
res = entry->res;
if (res->parent &&
(res->flags & (IORESOURCE_MEM | IORESOURCE_IO)))
release_resource(res);
resource_list_destroy_entry(entry);
}
kfree(info); kfree(info);
} }
static void release_pci_root_info(struct pci_host_bridge *bridge) static struct acpi_pci_root_ops pci_acpi_root_ops = {
{ .pci_ops = &pci_root_ops,
struct pci_root_info *info = bridge->release_data; .release_info = pci_acpi_root_release_info,
.prepare_resources = pci_acpi_root_prepare_resources,
__release_pci_root_info(info); };
}
struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root) struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
{ {
struct acpi_device *device = root->device; struct acpi_device *device = root->device;
int domain = root->segment;
int bus = root->secondary.start;
struct pci_root_info *info; struct pci_root_info *info;
struct pci_bus *pbus;
int ret;
info = kzalloc(sizeof(*info), GFP_KERNEL); info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info) { if (!info) {
dev_err(&device->dev, dev_err(&device->dev,
"pci_bus %04x:%02x: ignored (out of memory)\n", "pci_bus %04x:%02x: ignored (out of memory)\n",
domain, bus); root->segment, (int)root->secondary.start);
return NULL; return NULL;
} }
info->controller.segment = domain; info->controller.segment = root->segment;
info->controller.companion = device; info->controller.companion = device;
info->controller.node = acpi_get_node(device->handle); info->controller.node = acpi_get_node(device->handle);
info->bridge = device;
INIT_LIST_HEAD(&info->resources);
INIT_LIST_HEAD(&info->io_resources); INIT_LIST_HEAD(&info->io_resources);
snprintf(info->name, sizeof(info->name), return acpi_pci_root_create(root, &pci_acpi_root_ops,
"PCI Bus %04x:%02x", domain, bus); &info->common, &info->controller);
ret = probe_pci_root_info(info, device, bus, domain);
if (ret <= 0) {
kfree(info);
return NULL;
}
add_resources(info, &info->bridge->dev);
pci_add_resource(&info->resources, &root->secondary);
/*
* See arch/x86/pci/acpi.c.
* The desired pci bus might already be scanned in a quirk. We
* should handle the case here, but it appears that IA64 hasn't
* such quirk. So we just ignore the case now.
*/
pbus = pci_create_root_bus(NULL, bus, &pci_root_ops,
&info->controller, &info->resources);
if (!pbus) {
__release_pci_root_info(info);
return NULL;
}
pci_set_host_bridge_release(to_pci_host_bridge(pbus->bridge),
release_pci_root_info, info);
pci_scan_child_bus(pbus);
return pbus;
} }
int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge) int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)