a252d881c5
Given following simplified device hierarchy:
// PCI device having BAR0 (RMEM) split between 4 GPIO devices.
Device (P2S)
{
Name (_ADR, 0x000d0000)
Device (GPO0)
{
Name (_HID, "INT3452")
Name (_UID, 1)
Name (_CRS, ResourceTemplate () {
Memory32Fixed (ReadWrite, 0, 0x4000, RMEM + 0x0000)
})
}
Device (GPO1)
{
Name (_HID, "INT3452")
Name (_UID, 2)
Name (_CRS, ResourceTemplate () {
Memory32Fixed (ReadWrite, 0, 0x4000, RMEM + 0x4000)
})
}
Device (GPO2)
{
Name (_HID, "INT3452")
Name (_UID, 3)
Name (_CRS, ResourceTemplate () {
Memory32Fixed (ReadWrite, 0, 0x4000, RMEM + 0x8000)
})
}
Device (GPO3)
{
Name (_HID, "INT3452")
Name (_UID, 4)
Name (_CRS, ResourceTemplate () {
Memory32Fixed (ReadWrite, 0, 0x4000, RMEM + 0xc000)
})
}
}
The current ACPI platform enumeration code allocates resources from the
global MMIO resource pool (/proc/iomem) for all the four GPIO devices.
After this PCI core calls pcibios_resource_survey() to allocate resources
for all PCI devices including the parent device for these GPIO devices
(P2S). Since that resource range has already been reserved the allocation
fails.
The reason for this is that we never bother with parent device's resources
when ACPI platform devices are created.
Fix this by checking whether there is a parent device and in that case make
sure we assign correct parent resource to the resources for the child ACPI
platform device. Currently we only deal with parent devices if they are PCI
devices but we may expand this later to cover other bus types as well.
Reported-by: Aaron Durbin <adurbin@google.com>
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
127 lines
3.7 KiB
C
127 lines
3.7 KiB
C
/*
|
|
* ACPI support for platform bus type.
|
|
*
|
|
* Copyright (C) 2012, Intel Corporation
|
|
* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
|
|
* Mathias Nyman <mathias.nyman@linux.intel.com>
|
|
* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
|
|
*
|
|
* 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/acpi.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#include "internal.h"
|
|
|
|
ACPI_MODULE_NAME("platform");
|
|
|
|
static const struct acpi_device_id forbidden_id_list[] = {
|
|
{"PNP0000", 0}, /* PIC */
|
|
{"PNP0100", 0}, /* Timer */
|
|
{"PNP0200", 0}, /* AT DMA Controller */
|
|
{"", 0},
|
|
};
|
|
|
|
static void acpi_platform_fill_resource(struct acpi_device *adev,
|
|
const struct resource *src, struct resource *dest)
|
|
{
|
|
struct device *parent;
|
|
|
|
*dest = *src;
|
|
|
|
/*
|
|
* If the device has parent we need to take its resources into
|
|
* account as well because this device might consume part of those.
|
|
*/
|
|
parent = acpi_get_first_physical_node(adev->parent);
|
|
if (parent && dev_is_pci(parent))
|
|
dest->parent = pci_find_resource(to_pci_dev(parent), dest);
|
|
}
|
|
|
|
/**
|
|
* acpi_create_platform_device - Create platform device for ACPI device node
|
|
* @adev: ACPI device node to create a platform device for.
|
|
*
|
|
* Check if the given @adev can be represented as a platform device and, if
|
|
* that's the case, create and register a platform device, populate its common
|
|
* resources and returns a pointer to it. Otherwise, return %NULL.
|
|
*
|
|
* Name of the platform device will be the same as @adev's.
|
|
*/
|
|
struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
|
|
{
|
|
struct platform_device *pdev = NULL;
|
|
struct platform_device_info pdevinfo;
|
|
struct resource_entry *rentry;
|
|
struct list_head resource_list;
|
|
struct resource *resources = NULL;
|
|
int count;
|
|
|
|
/* If the ACPI node already has a physical device attached, skip it. */
|
|
if (adev->physical_node_count)
|
|
return NULL;
|
|
|
|
if (!acpi_match_device_ids(adev, forbidden_id_list))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
INIT_LIST_HEAD(&resource_list);
|
|
count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
|
|
if (count < 0) {
|
|
return NULL;
|
|
} else if (count > 0) {
|
|
resources = kzalloc(count * sizeof(struct resource),
|
|
GFP_KERNEL);
|
|
if (!resources) {
|
|
dev_err(&adev->dev, "No memory for resources\n");
|
|
acpi_dev_free_resource_list(&resource_list);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
count = 0;
|
|
list_for_each_entry(rentry, &resource_list, node)
|
|
acpi_platform_fill_resource(adev, rentry->res,
|
|
&resources[count++]);
|
|
|
|
acpi_dev_free_resource_list(&resource_list);
|
|
}
|
|
|
|
memset(&pdevinfo, 0, sizeof(pdevinfo));
|
|
/*
|
|
* If the ACPI node has a parent and that parent has a physical device
|
|
* attached to it, that physical device should be the parent of the
|
|
* platform device we are about to create.
|
|
*/
|
|
pdevinfo.parent = adev->parent ?
|
|
acpi_get_first_physical_node(adev->parent) : NULL;
|
|
pdevinfo.name = dev_name(&adev->dev);
|
|
pdevinfo.id = -1;
|
|
pdevinfo.res = resources;
|
|
pdevinfo.num_res = count;
|
|
pdevinfo.fwnode = acpi_fwnode_handle(adev);
|
|
|
|
if (acpi_dma_supported(adev))
|
|
pdevinfo.dma_mask = DMA_BIT_MASK(32);
|
|
else
|
|
pdevinfo.dma_mask = 0;
|
|
|
|
pdev = platform_device_register_full(&pdevinfo);
|
|
if (IS_ERR(pdev))
|
|
dev_err(&adev->dev, "platform device creation failed: %ld\n",
|
|
PTR_ERR(pdev));
|
|
else
|
|
dev_dbg(&adev->dev, "created platform device %s\n",
|
|
dev_name(&pdev->dev));
|
|
|
|
kfree(resources);
|
|
return pdev;
|
|
}
|
|
EXPORT_SYMBOL_GPL(acpi_create_platform_device);
|