51bd96b572
driver would verify that requests for child devices were confined to any existing I/O windows, but the driver relied on the firmware to initialize the windows and would never grow the windows for new requests. Now the driver actively manages the I/O windows. This is implemented by allocating a bus resource for each I/O window from the parent PCI bus and suballocating that resource to child devices. The suballocations are managed by creating an rman for each I/O window. The suballocated resources are mapped by passing the bus_activate_resource() call up to the parent PCI bus. Windows are grown when needed by using bus_adjust_resource() to adjust the resource allocated from the parent PCI bus. If the adjust request succeeds, the window is adjusted and the suballocation request for the child device is retried. When growing a window, the rman_first_free_region() and rman_last_free_region() routines are used to determine if the front or end of the existing I/O window is free. From using that, the smallest ranges that need to be added to either the front or back of the window are computed. The driver will first try to grow the window in whichever direction requires the smallest growth first followed by the other direction if that fails. Subtractive bridges will first attempt to satisfy requests for child resources from I/O windows (including attempts to grow the windows). If that fails, the request is passed up to the parent PCI bus directly however. The PCI-PCI bridge driver will try to use firmware-assigned ranges for child BARs first and only allocate a "fresh" range if that specific range cannot be accommodated in the I/O window. This allows systems where the firmware assigns resources during boot but later wipes the I/O windows (some ACPI BIOSen are known to do this) to "rediscover" the original I/O window ranges. The ACPI Host-PCI bridge driver has been adjusted to correctly honor hw.acpi.host_mem_start and the I/O port equivalent when a PCI-PCI bridge makes a wildcard request for an I/O window range. The new PCI-PCI bridge driver is only enabled if the NEW_PCIB kernel option is enabled. This is a transition aide to allow platforms that do not yet support bus_activate_resource() and bus_adjust_resource() in their Host-PCI bridge drivers (and possibly other drivers as needed) to use the old driver for now. Once all platforms support the new driver, the kernel option and old driver will be removed. PR: kern/143874 kern/149306 Tested by: mav
155 lines
4.5 KiB
C
155 lines
4.5 KiB
C
/*-
|
|
* Copyright (c) 2000 Michael Smith
|
|
* Copyright (c) 2000 BSDi
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "opt_acpi.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/module.h>
|
|
#include <sys/rman.h>
|
|
|
|
#include <contrib/dev/acpica/include/acpi.h>
|
|
#include <contrib/dev/acpica/include/accommon.h>
|
|
|
|
#include <dev/acpica/acpivar.h>
|
|
#include <dev/acpica/acpi_pcibvar.h>
|
|
|
|
#include <machine/pci_cfgreg.h>
|
|
#include <dev/pci/pcivar.h>
|
|
#include <dev/pci/pcireg.h>
|
|
#include <dev/pci/pcib_private.h>
|
|
#include "pcib_if.h"
|
|
|
|
/* Hooks for the ACPI CA debugging infrastructure. */
|
|
#define _COMPONENT ACPI_BUS
|
|
ACPI_MODULE_NAME("PCI_PCI")
|
|
|
|
struct acpi_pcib_softc {
|
|
struct pcib_softc ap_pcibsc;
|
|
ACPI_HANDLE ap_handle;
|
|
ACPI_BUFFER ap_prt; /* interrupt routing table */
|
|
};
|
|
|
|
struct acpi_pcib_lookup_info {
|
|
UINT32 address;
|
|
ACPI_HANDLE handle;
|
|
};
|
|
|
|
static int acpi_pcib_pci_probe(device_t bus);
|
|
static int acpi_pcib_pci_attach(device_t bus);
|
|
static int acpi_pcib_read_ivar(device_t dev, device_t child,
|
|
int which, uintptr_t *result);
|
|
static int acpi_pcib_pci_route_interrupt(device_t pcib,
|
|
device_t dev, int pin);
|
|
|
|
static device_method_t acpi_pcib_pci_methods[] = {
|
|
/* Device interface */
|
|
DEVMETHOD(device_probe, acpi_pcib_pci_probe),
|
|
DEVMETHOD(device_attach, acpi_pcib_pci_attach),
|
|
|
|
/* Bus interface */
|
|
DEVMETHOD(bus_read_ivar, acpi_pcib_read_ivar),
|
|
|
|
/* pcib interface */
|
|
DEVMETHOD(pcib_route_interrupt, acpi_pcib_pci_route_interrupt),
|
|
DEVMETHOD(pcib_power_for_sleep, acpi_pcib_power_for_sleep),
|
|
|
|
{0, 0}
|
|
};
|
|
|
|
static devclass_t pcib_devclass;
|
|
|
|
DEFINE_CLASS_1(pcib, acpi_pcib_pci_driver, acpi_pcib_pci_methods,
|
|
sizeof(struct acpi_pcib_softc), pcib_driver);
|
|
DRIVER_MODULE(acpi_pcib, pci, acpi_pcib_pci_driver, pcib_devclass, 0, 0);
|
|
MODULE_DEPEND(acpi_pcib, acpi, 1, 1, 1);
|
|
|
|
static int
|
|
acpi_pcib_pci_probe(device_t dev)
|
|
{
|
|
|
|
if (pci_get_class(dev) != PCIC_BRIDGE ||
|
|
pci_get_subclass(dev) != PCIS_BRIDGE_PCI ||
|
|
acpi_disabled("pci"))
|
|
return (ENXIO);
|
|
if (acpi_get_handle(dev) == NULL)
|
|
return (ENXIO);
|
|
if (pci_cfgregopen() == 0)
|
|
return (ENXIO);
|
|
|
|
device_set_desc(dev, "ACPI PCI-PCI bridge");
|
|
return (-1000);
|
|
}
|
|
|
|
static int
|
|
acpi_pcib_pci_attach(device_t dev)
|
|
{
|
|
struct acpi_pcib_softc *sc;
|
|
|
|
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
|
|
|
|
pcib_attach_common(dev);
|
|
sc = device_get_softc(dev);
|
|
sc->ap_handle = acpi_get_handle(dev);
|
|
return (acpi_pcib_attach(dev, &sc->ap_prt, sc->ap_pcibsc.secbus));
|
|
}
|
|
|
|
static int
|
|
acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
|
|
{
|
|
struct acpi_pcib_softc *sc = device_get_softc(dev);
|
|
|
|
switch (which) {
|
|
case ACPI_IVAR_HANDLE:
|
|
*result = (uintptr_t)sc->ap_handle;
|
|
return (0);
|
|
}
|
|
return (pcib_read_ivar(dev, child, which, result));
|
|
}
|
|
|
|
static int
|
|
acpi_pcib_pci_route_interrupt(device_t pcib, device_t dev, int pin)
|
|
{
|
|
struct acpi_pcib_softc *sc;
|
|
|
|
sc = device_get_softc(pcib);
|
|
|
|
/*
|
|
* If we don't have a _PRT, fall back to the swizzle method
|
|
* for routing interrupts.
|
|
*/
|
|
if (sc->ap_prt.Pointer == NULL)
|
|
return (pcib_route_interrupt(pcib, dev, pin));
|
|
else
|
|
return (acpi_pcib_route_interrupt(pcib, dev, pin, &sc->ap_prt));
|
|
}
|