Index: dev/acpica/acpi_pcib.c =================================================================== RCS file: /home/ncvs/src/sys/dev/acpica/acpi_pcib.c,v retrieving revision 1.24 diff -u -r1.24 acpi_pcib.c --- dev/acpica/acpi_pcib.c 5 Sep 2002 17:08:35 -0000 1.24 +++ dev/acpica/acpi_pcib.c 15 Sep 2002 02:59:06 -0000 @@ -98,7 +98,15 @@ * XXX It would be nice to defer this and count on the nexus getting it * after the first pass, but this does not seem to be reliable. */ + acpi_pci_link_config(dev, prt, busno); return_VALUE(bus_generic_attach(dev)); +} + +int +acpi_pcib_resume(device_t dev, ACPI_BUFFER *prt, int busno) +{ + acpi_pci_link_resume(dev, prt, busno); + return (bus_generic_resume(dev)); } /* Index: dev/acpica/acpi_pcib_acpi.c =================================================================== RCS file: /home/ncvs/src/sys/dev/acpica/acpi_pcib_acpi.c,v retrieving revision 1.23 diff -u -r1.23 acpi_pcib_acpi.c --- dev/acpica/acpi_pcib_acpi.c 26 Aug 2002 18:30:27 -0000 1.23 +++ dev/acpica/acpi_pcib_acpi.c 11 Sep 2002 17:56:12 -0000 @@ -62,6 +62,7 @@ static int acpi_pcib_acpi_probe(device_t bus); static int acpi_pcib_acpi_attach(device_t bus); +static int acpi_pcib_acpi_resume(device_t bus); static int acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result); static int acpi_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value); static u_int32_t acpi_pcib_read_config(device_t dev, int bus, int slot, int func, int reg, int bytes); @@ -76,7 +77,7 @@ DEVMETHOD(device_attach, acpi_pcib_acpi_attach), DEVMETHOD(device_shutdown, bus_generic_shutdown), DEVMETHOD(device_suspend, bus_generic_suspend), - DEVMETHOD(device_resume, bus_generic_resume), + DEVMETHOD(device_resume, acpi_pcib_acpi_resume), /* Bus interface */ DEVMETHOD(bus_print_child, bus_generic_print_child), @@ -178,6 +179,14 @@ } return (acpi_pcib_attach(dev, &sc->ap_prt, sc->ap_bus)); +} + +static int +acpi_pcib_acpi_resume(device_t dev) +{ + struct acpi_hpcib_softc *sc = device_get_softc(dev); + + return (acpi_pcib_resume(dev, &sc->ap_prt, sc->ap_bus)); } /* Index: dev/acpica/acpi_pcib_pci.c =================================================================== RCS file: /home/ncvs/src/sys/dev/acpica/acpi_pcib_pci.c,v retrieving revision 1.1 diff -u -r1.1 acpi_pcib_pci.c --- dev/acpica/acpi_pcib_pci.c 26 Aug 2002 18:30:27 -0000 1.1 +++ dev/acpica/acpi_pcib_pci.c 11 Sep 2002 17:56:46 -0000 @@ -64,6 +64,7 @@ static int acpi_pcib_pci_probe(device_t bus); static int acpi_pcib_pci_attach(device_t bus); +static int acpi_pcib_pci_resume(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); @@ -74,7 +75,7 @@ DEVMETHOD(device_attach, acpi_pcib_pci_attach), DEVMETHOD(device_shutdown, bus_generic_shutdown), DEVMETHOD(device_suspend, bus_generic_suspend), - DEVMETHOD(device_resume, bus_generic_resume), + DEVMETHOD(device_resume, acpi_pcib_pci_resume), /* Bus interface */ DEVMETHOD(bus_print_child, bus_generic_print_child), @@ -129,6 +130,14 @@ 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_pci_resume(device_t dev) +{ + struct acpi_pcib_softc *sc = device_get_softc(dev); + + return (acpi_pcib_resume(dev, &sc->ap_prt, sc->ap_pcibsc.secbus)); } static int Index: dev/acpica/acpi_pcibvar.h =================================================================== RCS file: /home/ncvs/src/sys/dev/acpica/acpi_pcibvar.h,v retrieving revision 1.1 diff -u -r1.1 acpi_pcibvar.h --- dev/acpica/acpi_pcibvar.h 26 Aug 2002 18:30:27 -0000 1.1 +++ dev/acpica/acpi_pcibvar.h 15 Sep 2002 02:58:47 -0000 @@ -33,5 +33,9 @@ int acpi_pcib_attach(device_t bus, ACPI_BUFFER *prt, int busno); int acpi_pcib_route_interrupt(device_t pcib, device_t dev, int pin, ACPI_BUFFER *ptrbuf); +int acpi_pcib_resume(device_t bus, ACPI_BUFFER *prt, int busno); + +int acpi_pci_link_config(device_t pcib, ACPI_BUFFER *prt, int busno); +int acpi_pci_link_resume(device_t pcib, ACPI_BUFFER *prt, int busno); #endif Index: modules/acpi/Makefile =================================================================== RCS file: /home/ncvs/src/sys/modules/acpi/Makefile,v retrieving revision 1.25 diff -u -r1.25 Makefile --- modules/acpi/Makefile 27 Aug 2002 13:39:31 -0000 1.25 +++ modules/acpi/Makefile 11 Sep 2002 19:10:00 -0000 @@ -39,6 +39,7 @@ SRCS+= acpi_ec.c acpi_lid.c acpi_pci.c acpi_pcib.c acpi_pcib_acpi.c SRCS+= acpi_pcib_pci.c acpi_powerres.c acpi_resource.c acpi_thermal.c SRCS+= acpi_timer.c acpica_support.c +SRCS+= acpi_pci_link.c SRCS+= OsdDebug.c SRCS+= OsdHardware.c OsdInterrupt.c OsdMemory.c OsdSchedule.c SRCS+= OsdStream.c OsdSynch.c OsdTable.c OsdEnvironment.c Index: conf/files =================================================================== RCS file: /home/ncvs/src/sys/conf/files,v retrieving revision 1.697 diff -u -r1.697 files --- conf/files 6 Sep 2002 17:12:50 -0000 1.697 +++ conf/files 15 Sep 2002 02:43:39 -0000 @@ -233,6 +233,7 @@ dev/acpica/acpi_ec.c optional acpica dev/acpica/acpi_lid.c optional acpica dev/acpica/acpi_pci.c optional acpica pci +dev/acpica/acpi_pci_link.c optional acpica pci dev/acpica/acpi_pcib.c optional acpica pci dev/acpica/acpi_pcib_acpi.c optional acpica pci dev/acpica/acpi_pcib_pci.c optional acpica pci --- /dev/null Sun Sep 15 11:55:00 2002 +++ dev/acpica/acpi_pci_link.c Sun Sep 15 11:58:11 2002 @@ -0,0 +1,1077 @@ +/*- + * Copyright (c) 2002 Mitsuru IWASAKI + * 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. + * + * $FreeBSD$ + */ + +#include "opt_acpi.h" +#include +#include +#include + +#include "acpi.h" + +#include +#include + +/* + * Hooks for the ACPI CA debugging infrastructure + */ +#define _COMPONENT ACPI_BUS +ACPI_MODULE_NAME("PCI_LINK") + +#define MAX_POSSIBLE_INTERRUPTS 16 +#define MAX_ISA_INTERRUPTS 16 +#define MAX_ACPI_INTERRUPTS 255 + +struct acpi_pci_link_entry { + TAILQ_ENTRY(acpi_pci_link_entry) links; + ACPI_HANDLE handle; + UINT8 current_irq; + UINT8 initial_irq; + ACPI_RESOURCE possible_resources; + UINT8 number_of_interrupts; + UINT8 interrupts[MAX_POSSIBLE_INTERRUPTS];; + + UINT8 sorted_irq[MAX_POSSIBLE_INTERRUPTS];; + int references; + int priority; +}; + +TAILQ_HEAD(acpi_pci_link_entries, acpi_pci_link_entry); +static struct acpi_pci_link_entries acpi_pci_link_entries; + +struct acpi_prt_entry { + TAILQ_ENTRY(acpi_prt_entry) links; + device_t pcidev; + int busno; + ACPI_PCI_ROUTING_TABLE prt; + struct acpi_pci_link_entry *pci_link; +}; + +TAILQ_HEAD(acpi_prt_entries, acpi_prt_entry); +static struct acpi_prt_entries acpi_prt_entries; + +static int irq_penalty[MAX_ACPI_INTERRUPTS]; + +#define ACPI_STA_PRESENT 0x00000001 +#define ACPI_STA_ENABLE 0x00000002 +#define ACPI_STA_SHOWINUI 0x00000004 +#define ACPI_STA_FUNCTIONAL 0x00000008 + +/* + * PCI link object management + */ + +static void +acpi_pci_link_entry_dump(struct acpi_prt_entry *entry) +{ + UINT8 i; + ACPI_RESOURCE_IRQ *Irq; + + if (entry == NULL || entry->pci_link == NULL) { + return; + } + + printf("%s irq %3d: ", acpi_name(entry->pci_link->handle), + entry->pci_link->current_irq); + + printf("["); + for (i = 0; i < entry->pci_link->number_of_interrupts; i++) { + printf("%3d", entry->pci_link->interrupts[i]); + } + printf("] "); + + Irq = NULL; + switch (entry->pci_link->possible_resources.Id) { + case ACPI_RSTYPE_IRQ: + Irq = &entry->pci_link->possible_resources.Data.Irq; + + switch (Irq->ActiveHighLow) { + case ACPI_ACTIVE_HIGH: + printf("high,"); + break; + + case ACPI_ACTIVE_LOW: + printf("low,"); + break; + + default: + printf("unkown,"); + break; + } + + switch (Irq->EdgeLevel) { + case ACPI_EDGE_SENSITIVE: + printf("edge,"); + break; + + case ACPI_LEVEL_SENSITIVE: + printf("level,"); + break; + + default: + printf("unkown,"); + break; + } + + switch (Irq->SharedExclusive) { + case ACPI_EXCLUSIVE: + printf("exclusive"); + break; + + case ACPI_SHARED: + printf("sharable"); + break; + + default: + printf("unkown"); + break; + } + + break; + + case ACPI_RSTYPE_EXT_IRQ: + /* TBD */ + break; + } + + printf(" %d.%d.%d", entry->busno, + (int)((entry->prt.Address & 0xffff0000) >> 16), + (int)entry->prt.Pin); + + printf("\n"); +} + +static ACPI_STATUS +acpi_pci_link_get_object_status(ACPI_HANDLE handle, UINT32 *sta) +{ + ACPI_DEVICE_INFO devinfo; + ACPI_STATUS error; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (handle == NULL || sta == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "invalid argument\n")); + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + error = AcpiGetObjectInfo(handle, &devinfo); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't get object info %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + if ((devinfo.Valid & ACPI_VALID_HID) == 0 || + strcmp(devinfo.HardwareId, "PNP0C0F") != 0) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid hardware ID - %s\n", + acpi_name(handle))); + return_ACPI_STATUS (AE_TYPE); + } + + if (devinfo.Valid & ACPI_VALID_STA) { + *sta = devinfo.CurrentStatus; + } else { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, "invalid status - %s\n", + acpi_name(handle))); + *sta = 0; + } + + return_ACPI_STATUS (AE_OK); +} + +static ACPI_STATUS +acpi_pci_link_get_irq_resources(ACPI_RESOURCE *resources, + UINT8 *number_of_interrupts, UINT8 interrupts[]) +{ + UINT8 count; + UINT8 i; + UINT32 NumberOfInterrupts; + UINT32 *Interrupts; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (resources == NULL || number_of_interrupts == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid argument\n")); + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + *number_of_interrupts = 0; + NumberOfInterrupts = 0; + Interrupts = NULL; + + if (resources->Id == ACPI_RSTYPE_START_DPF) + resources = ACPI_NEXT_RESOURCE(resources); + + if (resources->Id != ACPI_RSTYPE_IRQ && + resources->Id != ACPI_RSTYPE_EXT_IRQ) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "Resource is not an IRQ entry - %d\n", resources->Id)); + return_ACPI_STATUS (AE_TYPE); + } + + switch (resources->Id) { + case ACPI_RSTYPE_IRQ: + NumberOfInterrupts = resources->Data.Irq.NumberOfInterrupts; + Interrupts = resources->Data.Irq.Interrupts; + break; + + case ACPI_RSTYPE_EXT_IRQ: + NumberOfInterrupts = resources->Data.ExtendedIrq.NumberOfInterrupts; + Interrupts = resources->Data.ExtendedIrq.Interrupts; + break; + } + + if (NumberOfInterrupts == 0) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Blank IRQ resource\n")); + return_ACPI_STATUS (AE_NULL_ENTRY); + } + + count = 0; + for (i = 0; i < NumberOfInterrupts; i++) { + if (i >= MAX_POSSIBLE_INTERRUPTS) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, "too many IRQs %d\n", i)); + break; + } + + if (Interrupts[i] == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ %d\n", + Interrupts[i])); + continue; + } + interrupts[count] = Interrupts[i]; + count++; + } + *number_of_interrupts = count; + + return_ACPI_STATUS (AE_OK); +} + +static ACPI_STATUS +acpi_pci_link_get_current_irq(struct acpi_pci_link_entry *link, UINT8 *irq) +{ + ACPI_STATUS error; + ACPI_BUFFER buf; + ACPI_RESOURCE *resources; + UINT8 number_of_interrupts; + UINT8 interrupts[MAX_POSSIBLE_INTERRUPTS];; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (link == NULL || irq == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid argument\n")); + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + *irq = 0; + buf.Pointer = NULL; + buf.Length = ACPI_ALLOCATE_BUFFER; + error = AcpiGetCurrentResources(link->handle, &buf); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't get PCI interrupt link device _CRS %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + if (buf.Pointer == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't allocate memory - %s\n", + acpi_name(link->handle))); + return_ACPI_STATUS (AE_NO_MEMORY); + } + + resources = (ACPI_RESOURCE *) buf.Pointer; + + number_of_interrupts = 0; + bzero(interrupts, sizeof(interrupts)); + error = acpi_pci_link_get_irq_resources(resources, + &number_of_interrupts, interrupts); + AcpiOsFree(buf.Pointer); + + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get current IRQ from PCI interrupt link %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + if (number_of_interrupts == 0) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "PCI interrupt link device _CRS data is corrupted - %s\n", + acpi_name(link->handle))); + return_ACPI_STATUS (AE_NULL_ENTRY); + } + + *irq = interrupts[0]; + + return_ACPI_STATUS (AE_OK); +} + +static ACPI_STATUS +acpi_pci_link_add_link(ACPI_HANDLE handle, struct acpi_prt_entry *entry) +{ + ACPI_STATUS error; + ACPI_BUFFER buf; + ACPI_RESOURCE *resources; + struct acpi_pci_link_entry *link; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + entry->pci_link = NULL; + TAILQ_FOREACH(link, &acpi_pci_link_entries, links) { + if (link->handle == handle) { + entry->pci_link = link; + link->references++; + return_ACPI_STATUS (AE_OK); + } + } + + link = AcpiOsAllocate(sizeof(struct acpi_pci_link_entry)); + if (link == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't allocate memory - %s\n", acpi_name(handle))); + return_ACPI_STATUS (AE_NO_MEMORY); + } + + bzero(link, sizeof(struct acpi_pci_link_entry)); + + link->handle = handle; + + error = acpi_pci_link_get_current_irq(link, &link->current_irq); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get current IRQ from PCI interrupt link %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + goto out; + } + + link->initial_irq = link->current_irq; + + buf.Pointer = NULL; + buf.Length = ACPI_ALLOCATE_BUFFER; + error = AcpiGetPossibleResources(handle, &buf); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get PCI interrupt link device _PRS data %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + goto out; + } + + if (buf.Pointer == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "_PRS nuffer is empty - %s\n", acpi_name(handle))); + error = AE_NO_MEMORY; + goto out; + } + + resources = (ACPI_RESOURCE *) buf.Pointer; + bcopy(resources, &link->possible_resources, + sizeof(link->possible_resources)); + + error = acpi_pci_link_get_irq_resources(resources, + &link->number_of_interrupts, link->interrupts); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get possible IRQs from PCI interrupt link %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + goto out; + } + + if (link->number_of_interrupts == 0) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "PCI interrupt link device _PRS data is corrupted - %s\n", + acpi_name(handle))); + error = AE_NULL_ENTRY; + goto out; + } + + link->references++; + + TAILQ_INSERT_TAIL(&acpi_pci_link_entries, link, links); + entry->pci_link = link; + + error = AE_OK; +out: + if (buf.Pointer != NULL) { + AcpiOsFree(buf.Pointer); + } + + if (error != AE_OK && link != NULL) { + AcpiOsFree(link); + } + + return_ACPI_STATUS (error); +} + +static ACPI_STATUS +acpi_pci_link_add_prt(device_t pcidev, ACPI_PCI_ROUTING_TABLE *prt, int busno) +{ + ACPI_HANDLE handle; + ACPI_STATUS error; + UINT32 sta; + struct acpi_prt_entry *entry; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if ((prt == NULL) || (prt->Source == NULL) || (prt->Source[0] == '\0')) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't handle this routing table - hardwired\n")); + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + error = AcpiGetHandle(acpi_get_handle(pcidev), prt->Source, &handle); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't get acpi handle - %s\n", + AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + error = acpi_pci_link_get_object_status(handle, &sta); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't get object status %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + if (!(sta & ACPI_STA_ENABLE)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "PCI interrupt link is disabled - %s\n", + acpi_name(handle))); + return_ACPI_STATUS (AE_ERROR); + } + + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + if (entry->busno == busno && + entry->prt.Address == prt->Address && + entry->prt.Pin == prt->Pin) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "PCI interrupt link entry already exists - %s\n", + acpi_name(handle))); + return_ACPI_STATUS (AE_ALREADY_EXISTS); + } + } + + entry = AcpiOsAllocate(sizeof(struct acpi_prt_entry)); + if (entry == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't allocate memory - %s\n", acpi_name(handle))); + return_ACPI_STATUS (AE_NO_MEMORY); + } + + bzero(entry, sizeof(struct acpi_prt_entry)); + + entry->pcidev = pcidev; + entry->busno = busno; + bcopy(prt, &entry->prt, sizeof(entry->prt)); + + error = acpi_pci_link_add_link(handle, entry); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't add prt entry to pci link %s - %s\n", + acpi_name(handle), AcpiFormatException(error))); + goto out; + } + + TAILQ_INSERT_TAIL(&acpi_prt_entries, entry, links); + error = AE_OK; + +out: + if (error != AE_OK && entry != NULL) { + AcpiOsFree(entry); + } + + return_ACPI_STATUS (error); +} + +static int +acpi_pci_link_is_valid_irq(struct acpi_pci_link_entry *link, UINT8 irq) +{ + UINT8 i; + + if (irq == 0) { + return (0); + } + + for (i = 0; i < link->number_of_interrupts; i++) { + if (link->interrupts[i] == irq) { + return (1); + } + } + + /* allow initial IRQ as valid one. */ + if (link->initial_irq == irq) { + return (1); + } + + return (0); +} + +static ACPI_STATUS +acpi_pci_link_set_irq(struct acpi_pci_link_entry *link, UINT8 irq) +{ + ACPI_STATUS error; + ACPI_RESOURCE resbuf; + ACPI_BUFFER crsbuf; + UINT32 sta; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (!acpi_pci_link_is_valid_irq(link, irq)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't set invalid IRQ %d - %s\n", irq, + acpi_name(link->handle))); + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + error = acpi_pci_link_get_current_irq(link, &link->current_irq); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get current IRQ from PCI interrupt link %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + } + + if (link->current_irq == irq) { + return_ACPI_STATUS (AE_OK); + } + + bzero(&resbuf, sizeof(resbuf)); + crsbuf.Pointer = NULL; + resbuf.Id = ACPI_RSTYPE_IRQ; + resbuf.Length = ACPI_SIZEOF_RESOURCE(ACPI_RESOURCE_IRQ); + + if (link->possible_resources.Id != ACPI_RSTYPE_IRQ && + link->possible_resources.Id != ACPI_RSTYPE_EXT_IRQ) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "Resource is not an IRQ entry %s - %d\n", + acpi_name(link->handle), link->possible_resources.Id)); + return_ACPI_STATUS (AE_TYPE); + } + + switch (link->possible_resources.Id) { + case ACPI_RSTYPE_IRQ: + /* structure copy other fields */ + resbuf.Data.Irq = link->possible_resources.Data.Irq; + break; + + case ACPI_RSTYPE_EXT_IRQ: + /* XXX */ + resbuf.Data.Irq.EdgeLevel = ACPI_LEVEL_SENSITIVE; + resbuf.Data.Irq.ActiveHighLow = ACPI_ACTIVE_LOW; + resbuf.Data.Irq.SharedExclusive = ACPI_SHARED; + break; + } + + resbuf.Data.Irq.NumberOfInterrupts = 1; + resbuf.Data.Irq.Interrupts[0] = irq; + + error = acpi_AppendBufferResource(&crsbuf, &resbuf); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "couldn't setup buffer by acpi_AppendBufferResource - %s\n", + acpi_name(link->handle))); + return_ACPI_STATUS (error); + } + + if (crsbuf.Pointer == NULL) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "buffer setup by acpi_AppendBufferResource is corrupted - %s\n", + acpi_name(link->handle))); + return_ACPI_STATUS (AE_NO_MEMORY); + } + + error = AcpiSetCurrentResources(link->handle, &crsbuf); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't set PCI interrupt link device _SRS %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + AcpiOsFree(crsbuf.Pointer); + link->current_irq = 0; + + error = acpi_pci_link_get_object_status(link->handle, &sta); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get object status %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + if (!(sta & ACPI_STA_ENABLE)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "PCI interrupt link is disabled - %s\n", + acpi_name(link->handle))); + return_ACPI_STATUS (AE_ERROR); + } + + error = acpi_pci_link_get_current_irq(link, &link->current_irq); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't get current IRQ from PCI interrupt link %s - %s\n", + acpi_name(link->handle), AcpiFormatException(error))); + return_ACPI_STATUS (error); + } + + if (link->current_irq == irq) { + error = AE_OK; + } else { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't set IRQ %d to PCI interrupt link %d - %s\n", + irq, link->current_irq, acpi_name(link->handle))); + + link->current_irq = 0; + error = AE_ERROR; + } + + return_ACPI_STATUS (error); +} + +/* + * Auto arbitration for boot-disabled devices + */ + +static void +acpi_pci_link_bootdisabled_dump(void) + +{ + int i; + int irq; + struct acpi_pci_link_entry *link; + + TAILQ_FOREACH(link, &acpi_pci_link_entries, links) { + /* boot-disabled link only. */ + if (link->current_irq != 0) { + continue; + } + + printf("%s:\n", acpi_name(link->handle)); + printf(" interrupts: "); + for (i = 0; i < link->number_of_interrupts; i++) { + irq = link->sorted_irq[i]; + printf("%6d", irq); + } + printf("\n"); + printf(" penalty: "); + for (i = 0; i < link->number_of_interrupts; i++) { + irq = link->sorted_irq[i]; + printf("%6d", irq_penalty[irq]); + } + printf("\n"); + printf(" references: %d\n", link->references); + printf(" priority: %d\n", link->priority); + } +} + +static void +acpi_pci_link_init_irq_penalty(void) +{ + int irq; + + bzero(irq_penalty, sizeof(irq_penalty)); + for (irq = 0; irq < MAX_ISA_INTERRUPTS; irq++) { + /* 0, 1, 2, 8: timer, keyboard, cascade */ + if (irq == 0 || irq == 1 || irq == 2 || irq == 8) { + irq_penalty[irq] = 100000; + continue; + } + + /* 13, 14, 15: npx, ATA controllers */ + if (irq == 13 || irq == 14 || irq == 15) { + irq_penalty[irq] = 10000; + continue; + } + + /* 3,4,6,7,12: typicially used by legacy hardware */ + if (irq == 3 || irq == 4 || irq == 6 || irq == 7 || irq == 12) { + irq_penalty[irq] = 1000; + continue; + } + } +} + +static int +acpi_pci_link_is_irq_exclusive(ACPI_RESOURCE *res) +{ + if (res == NULL) { + return (0); + } + + if (res->Id != ACPI_RSTYPE_IRQ && + res->Id != ACPI_RSTYPE_EXT_IRQ) { + return (0); + } + + if (res->Id == ACPI_RSTYPE_IRQ && + res->Data.Irq.SharedExclusive == ACPI_EXCLUSIVE) { + return (1); + } + + if (res->Id == ACPI_RSTYPE_EXT_IRQ && + res->Data.ExtendedIrq.SharedExclusive == ACPI_EXCLUSIVE) { + return (1); + } + + return (0); +} + +static void +acpi_pci_link_update_irq_penalty(device_t dev, int busno) +{ + int i; + int irq; + int rid; + struct resource *res; + struct acpi_prt_entry *entry; + struct acpi_pci_link_entry *link; + + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + if (entry->busno != busno) { + continue; + } + + link = entry->pci_link; + if (link == NULL) { + continue; /* impossible... */ + } + + if (link->current_irq != 0) { + /* not boot-disabled link, we will use this IRQ. */ + irq_penalty[link->current_irq] += 100; + continue; + } + + /* boot-disabled link */ + for (i = 0; i < link->number_of_interrupts; i++) { + /* give 10 for each possible IRQs. */ + irq = link->interrupts[i]; + irq_penalty[irq] += 10; + + /* higher penalty if exclusive. */ + if (acpi_pci_link_is_irq_exclusive(&link->possible_resources)) { + irq_penalty[irq] += 100; + } + + /* XXX try to get this IRQ in non-sharable mode. */ + rid = 0; + res = bus_alloc_resource(dev, SYS_RES_IRQ, + &rid, irq, irq, 1, 0); + if (res != NULL) { + bus_release_resource(dev, SYS_RES_IRQ, + rid, res); + } else { + /* this is in use, give 100. */ + irq_penalty[irq] += 100; + } + } + + /* initialize `sorted' possible IRQs. */ + bcopy(link->interrupts, link->sorted_irq, + sizeof(link->sorted_irq)); + } +} + +static void +acpi_pci_link_set_bootdisabled_priority(void) +{ + int sum_penalty; + int i; + int irq; + struct acpi_pci_link_entry *link, *link_pri; + TAILQ_HEAD(, acpi_pci_link_entry) sorted_list; + + if (bootverbose || 1) { + printf("---- before setting priority for links ------------\n"); + acpi_pci_link_bootdisabled_dump(); + } + + /* reset priority for all links. */ + TAILQ_FOREACH(link, &acpi_pci_link_entries, links) { + link->priority = 0; + } + + TAILQ_FOREACH(link, &acpi_pci_link_entries, links) { + /* not boot-disabled link, give no chance to be arbitrated. */ + if (link->current_irq != 0) { + link->priority = 0; + continue; + } + + /* + * Calculate the priority for each boot-disabled links. + * o IRQ penalty indicates difficulty to use. + * o #references for devices indicates importance of the link. + * o #interrupts indicates flexibility of the link. + */ + sum_penalty = 0; + for (i = 0; i < link->number_of_interrupts; i++) { + irq = link->interrupts[i]; + sum_penalty += irq_penalty[irq]; + } + + link->priority = (sum_penalty * link->references) / link->number_of_interrupts; + } + + /* + * Sort PCI links based on the priority. + * XXX Any other better ways rather than using work list? + */ + TAILQ_INIT(&sorted_list); + while (!TAILQ_EMPTY(&acpi_pci_link_entries)) { + link = TAILQ_FIRST(&acpi_pci_link_entries); + /* find a entry which have the highest priority. */ + TAILQ_FOREACH(link_pri, &acpi_pci_link_entries, links) { + if (link->priority < link_pri->priority) { + link = link_pri; + } + } + /* move to work list. */ + TAILQ_REMOVE(&acpi_pci_link_entries, link, links); + TAILQ_INSERT_TAIL(&sorted_list, link, links); + } + + while (!TAILQ_EMPTY(&sorted_list)) { + /* move them back to the list, one by one... */ + link = TAILQ_FIRST(&sorted_list); + TAILQ_REMOVE(&sorted_list, link, links); + TAILQ_INSERT_TAIL(&acpi_pci_link_entries, link, links); + } +} + +static void +acpi_pci_link_fixup_bootdisabled_link(void) +{ + int i, j; + int irq1, irq2; + struct acpi_pci_link_entry *link; + ACPI_STATUS error; + + if (bootverbose || 1) { + printf("---- before fixup boot-disabled links -------------\n"); + acpi_pci_link_bootdisabled_dump(); + } + + TAILQ_FOREACH(link, &acpi_pci_link_entries, links) { + /* ignore non boot-disabled links. */ + if (link->current_irq != 0) { + continue; + } + + /* sort IRQs based on their penalty descending. */ + for (i = 0; i < link->number_of_interrupts; i++) { + irq1 = link->sorted_irq[i]; + for (j = i + 1; j < link->number_of_interrupts; j++) { + irq2 = link->sorted_irq[j]; + if (irq_penalty[irq1] < irq_penalty[irq2]) { + continue; + } + link->sorted_irq[i] = irq2; + link->sorted_irq[j] = irq1; + irq1 = irq2; + } + } + + /* try with lower penalty IRQ. */ + for (i = 0; i < link->number_of_interrupts - 1; i++) { + irq1 = link->sorted_irq[i]; + error = acpi_pci_link_set_irq(link, irq1); + if (error == AE_OK) { + /* OK, we use this. give another penalty. */ + irq_penalty[irq1] += 100 * link->references; + break; + } + /* NG, try next IRQ... */ + } + } + + if (bootverbose || 1) { + printf("---- after fixup boot-disabled links --------------\n"); + acpi_pci_link_bootdisabled_dump(); + } +} + +/* + * Public interface + */ + +int +acpi_pci_link_config(device_t dev, ACPI_BUFFER *prtbuf, int busno) +{ + struct acpi_prt_entry *entry; + ACPI_PCI_ROUTING_TABLE *prt; + u_int8_t *prtp; + ACPI_STATUS error; + static int first_time =1; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (acpi_disabled("pci_link")) { + return (0); + } + + if (first_time) { + TAILQ_INIT(&acpi_prt_entries); + TAILQ_INIT(&acpi_pci_link_entries); + acpi_pci_link_init_irq_penalty(); + first_time = 0; + } + + if (prtbuf == NULL) { + return (-1); + } + + prtp = prtbuf->Pointer; + if (prtp == NULL) { /* didn't get routing table */ + return (-1); + } + + /* scan the PCI Routing Table */ + for (;;) { + prt = (ACPI_PCI_ROUTING_TABLE *)prtp; + + if (prt->Length == 0) /* end of table */ + break; + + error = acpi_pci_link_add_prt(dev, prt, busno); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't add PCI interrupt link entry - %s\n", + AcpiFormatException(error))); + } + + /* skip to next entry */ + prtp += prt->Length; + } + + if (bootverbose || 1) { + printf("---- initial configuration ------------------------\n"); + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + if (entry->busno != busno) { + continue; + } + + acpi_pci_link_entry_dump(entry); + } + } + + /* manual configuration. */ + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + UINT8 irq; + char *irqstr, *op; + char prthint[32]; + + if (entry->busno != busno) { + continue; + } + + snprintf(prthint, sizeof(prthint), + "hw.acpi.pci.link.%d.%d.%d.irq", entry->busno, + (int)((entry->prt.Address & 0xffff0000) >> 16), + (int)entry->prt.Pin); + + irqstr = getenv(prthint); + if (irqstr == NULL) { + continue; + } + + irq = strtoul(irqstr, &op, 0); + if (*op != '\0') { + continue; + } + + if (acpi_pci_link_is_valid_irq(entry->pci_link, irq)) { + error = acpi_pci_link_set_irq(entry->pci_link, irq); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't set IRQ to PCI interrupt link entry %s - %s\n", + acpi_name(entry->pci_link->handle), + AcpiFormatException(error))); + } + continue; + } + + /* + * Do auto arbitration for this device's PCI link + * if hint value 0 is specified. + */ + if (irq == 0) { + entry->pci_link->current_irq = 0; + } + } + + /* auto arbitration */ + acpi_pci_link_update_irq_penalty(dev, busno); + acpi_pci_link_set_bootdisabled_priority(); + acpi_pci_link_fixup_bootdisabled_link(); + + if (bootverbose || 1) { + printf("---- arbitrated configuration ---------------------\n"); + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + if (entry->busno != busno) { + continue; + } + + acpi_pci_link_entry_dump(entry); + } + } + + return (0); +} + +int +acpi_pci_link_resume(device_t dev, ACPI_BUFFER *prtbuf, int busno) +{ + struct acpi_prt_entry *entry; + ACPI_STATUS error; + + ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); + + if (acpi_disabled("pci_link")) { + return (0); + } + + TAILQ_FOREACH(entry, &acpi_prt_entries, links) { + if (entry->pcidev != dev) { + continue; + } + + error = acpi_pci_link_set_irq(entry->pci_link, + entry->pci_link->current_irq); + if (ACPI_FAILURE(error)) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "couldn't set IRQ to PCI interrupt link entry %s - %s\n", + acpi_name(entry->pci_link->handle), + AcpiFormatException(error))); + } + } + + return (0); +} +