mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-15 03:12:35 +03:00
610 lines
18 KiB
C
610 lines
18 KiB
C
|
|
#include <ddk.h>
|
|
#include <linux/errno.h>
|
|
#include <mutex.h>
|
|
#include <linux/spinlock.h>
|
|
#include <pci.h>
|
|
#include <syscall.h>
|
|
|
|
#include "acpi.h"
|
|
#include "acpi_bus.h"
|
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
struct acpi_prt_entry
|
|
{
|
|
struct list_head list;
|
|
ACPI_PCI_ID id;
|
|
u8 pin;
|
|
ACPI_HANDLE link;
|
|
u32 index; /* GSI, or link _CRS index */
|
|
};
|
|
|
|
static LIST_HEAD(acpi_prt_list);
|
|
static DEFINE_SPINLOCK(acpi_prt_lock);
|
|
|
|
static inline char pin_name(int pin)
|
|
{
|
|
return 'A' + pin - 1;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
PCI IRQ Routing Table (PRT) Support
|
|
-------------------------------------------------------------------------- */
|
|
|
|
static struct acpi_prt_entry *acpi_pci_irq_find_prt_entry(struct pci_dev *dev,
|
|
int pin)
|
|
{
|
|
struct acpi_prt_entry *entry;
|
|
int segment = pci_domain_nr(dev->bus);
|
|
int bus = dev->bus->number;
|
|
int device = PCI_SLOT(dev->devfn);
|
|
|
|
spin_lock(&acpi_prt_lock);
|
|
list_for_each_entry(entry, &acpi_prt_list, list) {
|
|
if ((segment == entry->id.Segment)
|
|
&& (bus == entry->id.Bus)
|
|
&& (device == entry->id.Device)
|
|
&& (pin == entry->pin)) {
|
|
spin_unlock(&acpi_prt_lock);
|
|
return entry;
|
|
}
|
|
}
|
|
spin_unlock(&acpi_prt_lock);
|
|
return NULL;
|
|
}
|
|
|
|
static int acpi_pci_irq_add_entry(ACPI_HANDLE handle, struct pci_bus *bus,
|
|
struct acpi_pci_routing_table *prt)
|
|
{
|
|
struct acpi_prt_entry *entry;
|
|
|
|
entry = kzalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
|
|
if (!entry)
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
* Note that the _PRT uses 0=INTA, 1=INTB, etc, while PCI uses
|
|
* 1=INTA, 2=INTB. We use the PCI encoding throughout, so convert
|
|
* it here.
|
|
*/
|
|
entry->id.Segment = pci_domain_nr(bus);
|
|
entry->id.Bus = bus->number;
|
|
entry->id.Device = (prt->Address >> 16) & 0xFFFF;
|
|
entry->pin = prt->Pin + 1;
|
|
|
|
// do_prt_fixups(entry, prt);
|
|
|
|
entry->index = prt->SourceIndex;
|
|
|
|
/*
|
|
* Type 1: Dynamic
|
|
* ---------------
|
|
* The 'source' field specifies the PCI interrupt link device used to
|
|
* configure the IRQ assigned to this slot|dev|pin. The 'source_index'
|
|
* indicates which resource descriptor in the resource template (of
|
|
* the link device) this interrupt is allocated from.
|
|
*
|
|
* NOTE: Don't query the Link Device for IRQ information at this time
|
|
* because Link Device enumeration may not have occurred yet
|
|
* (e.g. exists somewhere 'below' this _PRT entry in the ACPI
|
|
* namespace).
|
|
*/
|
|
if (prt->Source[0])
|
|
AcpiGetHandle(handle, prt->Source, &entry->link);
|
|
|
|
/*
|
|
* Type 2: Static
|
|
* --------------
|
|
* The 'source' field is NULL, and the 'source_index' field specifies
|
|
* the IRQ value, which is hardwired to specific interrupt inputs on
|
|
* the interrupt controller.
|
|
*/
|
|
|
|
dbgprintf(PREFIX " %04x:%02x:%02x[%c] -> %s[%d]\n",
|
|
entry->id.Segment, entry->id.Bus,
|
|
entry->id.Device, pin_name(entry->pin),
|
|
prt->Source, entry->index);
|
|
|
|
spin_lock(&acpi_prt_lock);
|
|
list_add_tail(&entry->list, &acpi_prt_list);
|
|
spin_unlock(&acpi_prt_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int acpi_pci_irq_add_prt(ACPI_HANDLE handle, struct pci_bus *bus)
|
|
{
|
|
ACPI_STATUS status;
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
struct acpi_pci_routing_table *entry;
|
|
|
|
/* 'handle' is the _PRT's parent (root bridge or PCI-PCI bridge) */
|
|
status = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
|
|
printk(KERN_DEBUG "ACPI: PCI Interrupt Routing Table [%s._PRT]\n",
|
|
(char *) buffer.Pointer);
|
|
|
|
kfree(buffer.Pointer);
|
|
|
|
buffer.Length = ACPI_ALLOCATE_BUFFER;
|
|
buffer.Pointer = NULL;
|
|
|
|
status = AcpiGetIrqRoutingTable(handle, &buffer);
|
|
if (ACPI_FAILURE(status))
|
|
{
|
|
dbgprintf("AcpiGetIrqRoutingTable failed "
|
|
"evaluating _PRT [%s]\n",AcpiFormatException(status));
|
|
kfree(buffer.Pointer);
|
|
return -ENODEV;
|
|
}
|
|
|
|
entry = buffer.Pointer;
|
|
while (entry && (entry->Length > 0)) {
|
|
acpi_pci_irq_add_entry(handle, bus, entry);
|
|
entry = (struct acpi_pci_routing_table *)
|
|
((unsigned long)entry + entry->Length);
|
|
}
|
|
|
|
kfree(buffer.Pointer);
|
|
return 0;
|
|
}
|
|
|
|
static struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin)
|
|
{
|
|
struct acpi_prt_entry *entry;
|
|
struct pci_dev *bridge;
|
|
u8 bridge_pin, orig_pin = pin;
|
|
|
|
entry = acpi_pci_irq_find_prt_entry(dev, pin);
|
|
if (entry) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %s[%c] _PRT entry\n",
|
|
pci_name(dev), pin_name(pin)));
|
|
return entry;
|
|
}
|
|
|
|
/*
|
|
* Attempt to derive an IRQ for this device from a parent bridge's
|
|
* PCI interrupt routing entry (eg. yenta bridge and add-in card bridge).
|
|
*/
|
|
bridge = dev->bus->self;
|
|
while (bridge)
|
|
{
|
|
pin = pci_swizzle_interrupt_pin(dev, pin);
|
|
|
|
if ((bridge->class >> 8) == PCI_CLASS_BRIDGE_CARDBUS) {
|
|
/* PC card has the same IRQ as its cardbridge */
|
|
bridge_pin = bridge->pin;
|
|
if (!bridge_pin) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
"No interrupt pin configured for device %s\n",
|
|
pci_name(bridge)));
|
|
return NULL;
|
|
}
|
|
pin = bridge_pin;
|
|
}
|
|
|
|
entry = acpi_pci_irq_find_prt_entry(bridge, pin);
|
|
if (entry) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
"Derived GSI for %s INT %c from %s\n",
|
|
pci_name(dev), pin_name(orig_pin),
|
|
pci_name(bridge)));
|
|
return entry;
|
|
}
|
|
|
|
dev = bridge;
|
|
bridge = dev->bus->self;
|
|
}
|
|
|
|
dbgprintf("can't derive routing for PCI INT %c\n",
|
|
pin_name(orig_pin));
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int acpi_get_irq(struct pci_dev *dev)
|
|
{
|
|
struct acpi_prt_entry *entry;
|
|
int gsi = -1;
|
|
u8 pin;
|
|
|
|
int triggering = ACPI_LEVEL_SENSITIVE;
|
|
int polarity = ACPI_ACTIVE_LOW;
|
|
|
|
char *link = NULL;
|
|
char link_desc[16];
|
|
int rc;
|
|
|
|
pin = dev->pin;
|
|
|
|
if ( !pin )
|
|
{
|
|
dbgprintf("No interrupt pin configured for device %s\n",
|
|
pci_name(dev));
|
|
return 0;
|
|
}
|
|
|
|
entry = acpi_pci_irq_lookup(dev, pin);
|
|
if (!entry) {
|
|
/*
|
|
* IDE legacy mode controller IRQs are magic. Why do compat
|
|
* extensions always make such a nasty mess.
|
|
*/
|
|
if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE &&
|
|
(dev->class & 0x05) == 0)
|
|
return 0;
|
|
}
|
|
|
|
if (entry)
|
|
{
|
|
if (entry->link)
|
|
{
|
|
gsi = acpi_pci_link_allocate_irq(entry->link,
|
|
entry->index,
|
|
&triggering, &polarity,
|
|
&link);
|
|
// dbgprintf("link not implemen\n");
|
|
}
|
|
else
|
|
gsi = entry->index;
|
|
} else
|
|
gsi = -1;
|
|
|
|
#if 0
|
|
|
|
/*
|
|
* No IRQ known to the ACPI subsystem - maybe the BIOS /
|
|
* driver reported one, then use it. Exit in any case.
|
|
*/
|
|
if (gsi < 0) {
|
|
u32 dev_gsi;
|
|
dev_warn(&dev->dev, "PCI INT %c: no GSI", pin_name(pin));
|
|
/* Interrupt Line values above 0xF are forbidden */
|
|
if (dev->irq > 0 && (dev->irq <= 0xF) &&
|
|
(acpi_isa_irq_to_gsi(dev->irq, &dev_gsi) == 0)) {
|
|
printk(" - using ISA IRQ %d\n", dev->irq);
|
|
acpi_register_gsi(&dev->dev, dev_gsi,
|
|
ACPI_LEVEL_SENSITIVE,
|
|
ACPI_ACTIVE_LOW);
|
|
return 0;
|
|
} else {
|
|
printk("\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
rc = acpi_register_gsi(&dev->dev, gsi, triggering, polarity);
|
|
if (rc < 0) {
|
|
dev_warn(&dev->dev, "PCI INT %c: failed to register GSI\n",
|
|
pin_name(pin));
|
|
return rc;
|
|
}
|
|
dev->irq = rc;
|
|
|
|
if (link)
|
|
snprintf(link_desc, sizeof(link_desc), " -> Link[%s]", link);
|
|
else
|
|
link_desc[0] = '\0';
|
|
|
|
dev_info(&dev->dev, "PCI INT %c%s -> GSI %u (%s, %s) -> IRQ %d\n",
|
|
pin_name(pin), link_desc, gsi,
|
|
(triggering == ACPI_LEVEL_SENSITIVE) ? "level" : "edge",
|
|
(polarity == ACPI_ACTIVE_LOW) ? "low" : "high", dev->irq);
|
|
#endif
|
|
return gsi;
|
|
}
|
|
|
|
|
|
#define ACPI_PCI_LINK_MAX_POSSIBLE 16
|
|
|
|
/*
|
|
* If a link is initialized, we never change its active and initialized
|
|
* later even the link is disable. Instead, we just repick the active irq
|
|
*/
|
|
struct acpi_pci_link_irq {
|
|
u8 active; /* Current IRQ */
|
|
u8 triggering; /* All IRQs */
|
|
u8 polarity; /* All IRQs */
|
|
u8 resource_type;
|
|
u8 possible_count;
|
|
u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
|
|
u8 initialized:1;
|
|
u8 reserved:7;
|
|
};
|
|
|
|
struct acpi_pci_link {
|
|
struct list_head list;
|
|
struct acpi_device *device;
|
|
struct acpi_pci_link_irq irq;
|
|
int refcnt;
|
|
};
|
|
|
|
static LIST_HEAD(acpi_link_list);
|
|
static DEFINE_MUTEX(acpi_link_lock);
|
|
|
|
|
|
static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
|
|
{
|
|
int result;
|
|
ACPI_STATUS status;
|
|
struct {
|
|
struct acpi_resource res;
|
|
struct acpi_resource end;
|
|
} *resource;
|
|
|
|
ACPI_BUFFER buffer = { 0, NULL };
|
|
|
|
if (!irq)
|
|
return -EINVAL;
|
|
|
|
resource = kzalloc(sizeof(*resource) + 1, GFP_KERNEL);
|
|
if (!resource)
|
|
return -ENOMEM;
|
|
|
|
buffer.Length = sizeof(*resource) + 1;
|
|
buffer.Pointer = resource;
|
|
|
|
switch (link->irq.resource_type) {
|
|
case ACPI_RESOURCE_TYPE_IRQ:
|
|
resource->res.Type = ACPI_RESOURCE_TYPE_IRQ;
|
|
resource->res.Length = sizeof(struct acpi_resource);
|
|
resource->res.Data.Irq.Triggering = link->irq.triggering;
|
|
resource->res.Data.Irq.Polarity =
|
|
link->irq.polarity;
|
|
if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
|
|
resource->res.Data.Irq.Sharable =
|
|
ACPI_EXCLUSIVE;
|
|
else
|
|
resource->res.Data.Irq.Sharable = ACPI_SHARED;
|
|
resource->res.Data.Irq.InterruptCount = 1;
|
|
resource->res.Data.Irq.Interrupts[0] = irq;
|
|
break;
|
|
|
|
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
|
|
resource->res.Type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
|
|
resource->res.Length = sizeof(struct acpi_resource);
|
|
resource->res.Data.ExtendedIrq.ProducerConsumer =
|
|
ACPI_CONSUMER;
|
|
resource->res.Data.ExtendedIrq.Triggering =
|
|
link->irq.triggering;
|
|
resource->res.Data.ExtendedIrq.Polarity =
|
|
link->irq.polarity;
|
|
if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
|
|
resource->res.Data.Irq.Sharable =
|
|
ACPI_EXCLUSIVE;
|
|
else
|
|
resource->res.Data.Irq.Sharable = ACPI_SHARED;
|
|
resource->res.Data.ExtendedIrq.InterruptCount = 1;
|
|
resource->res.Data.ExtendedIrq.Interrupts[0] = irq;
|
|
/* ignore resource_source, it's optional */
|
|
break;
|
|
default:
|
|
printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
|
|
result = -EINVAL;
|
|
goto end;
|
|
|
|
}
|
|
resource->end.Type = ACPI_RESOURCE_TYPE_END_TAG;
|
|
|
|
#if 0
|
|
/* Attempt to set the resource */
|
|
status = acpi_set_current_resources(link->device->handle, &buffer);
|
|
|
|
/* check for total failure */
|
|
if (ACPI_FAILURE(status)) {
|
|
dbgprintf("%s failure Evaluating _SRS", __FUNCTION__);
|
|
result = -ENODEV;
|
|
goto end;
|
|
}
|
|
|
|
/* Query _STA, set device->status */
|
|
result = acpi_bus_get_status(link->device);
|
|
if (result) {
|
|
printk(KERN_ERR PREFIX "Unable to read status\n");
|
|
goto end;
|
|
}
|
|
if (!link->device->status.enabled) {
|
|
printk(KERN_WARNING PREFIX
|
|
"%s [%s] disabled and referenced, BIOS bug\n",
|
|
acpi_device_name(link->device),
|
|
acpi_device_bid(link->device));
|
|
}
|
|
|
|
/* Query _CRS, set link->irq.active */
|
|
result = acpi_pci_link_get_current(link);
|
|
if (result) {
|
|
goto end;
|
|
}
|
|
|
|
/*
|
|
* Is current setting not what we set?
|
|
* set link->irq.active
|
|
*/
|
|
if (link->irq.active != irq) {
|
|
/*
|
|
* policy: when _CRS doesn't return what we just _SRS
|
|
* assume _SRS worked and override _CRS value.
|
|
*/
|
|
printk(KERN_WARNING PREFIX
|
|
"%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
|
|
acpi_device_name(link->device),
|
|
acpi_device_bid(link->device), link->irq.active, irq);
|
|
link->irq.active = irq;
|
|
}
|
|
#endif
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));
|
|
|
|
end:
|
|
kfree(resource);
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
#define ACPI_MAX_IRQS 256
|
|
#define ACPI_MAX_ISA_IRQ 16
|
|
|
|
#define PIRQ_PENALTY_PCI_AVAILABLE (0)
|
|
#define PIRQ_PENALTY_PCI_POSSIBLE (16*16)
|
|
#define PIRQ_PENALTY_PCI_USING (16*16*16)
|
|
#define PIRQ_PENALTY_ISA_TYPICAL (16*16*16*16)
|
|
#define PIRQ_PENALTY_ISA_USED (16*16*16*16*16)
|
|
#define PIRQ_PENALTY_ISA_ALWAYS (16*16*16*16*16*16)
|
|
|
|
static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
|
|
PIRQ_PENALTY_ISA_ALWAYS, /* IRQ0 timer */
|
|
PIRQ_PENALTY_ISA_ALWAYS, /* IRQ1 keyboard */
|
|
PIRQ_PENALTY_ISA_ALWAYS, /* IRQ2 cascade */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ3 serial */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ4 serial */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ5 sometimes SoundBlaster */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ6 */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ7 parallel, spurious */
|
|
PIRQ_PENALTY_ISA_TYPICAL, /* IRQ8 rtc, sometimes */
|
|
PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ9 PCI, often acpi */
|
|
PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ10 PCI */
|
|
PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ11 PCI */
|
|
PIRQ_PENALTY_ISA_USED, /* IRQ12 mouse */
|
|
PIRQ_PENALTY_ISA_USED, /* IRQ13 fpe, sometimes */
|
|
PIRQ_PENALTY_ISA_USED, /* IRQ14 ide0 */
|
|
PIRQ_PENALTY_ISA_USED, /* IRQ15 ide1 */
|
|
/* >IRQ15 */
|
|
};
|
|
|
|
|
|
|
|
|
|
static int acpi_irq_balance = 0;
|
|
|
|
static int acpi_pci_link_allocate(struct acpi_pci_link *link)
|
|
{
|
|
int irq;
|
|
int i;
|
|
|
|
if (link->irq.initialized) {
|
|
if (link->refcnt == 0)
|
|
/* This means the link is disabled but initialized */
|
|
acpi_pci_link_set(link, link->irq.active);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* search for active IRQ in list of possible IRQs.
|
|
*/
|
|
for (i = 0; i < link->irq.possible_count; ++i) {
|
|
if (link->irq.active == link->irq.possible[i])
|
|
break;
|
|
}
|
|
/*
|
|
* forget active IRQ that is not in possible list
|
|
*/
|
|
if (i == link->irq.possible_count) {
|
|
dbgprintf(KERN_WARNING PREFIX "_CRS %d not found"
|
|
" in _PRS\n", link->irq.active);
|
|
link->irq.active = 0;
|
|
}
|
|
|
|
/*
|
|
* if active found, use it; else pick entry from end of possible list.
|
|
*/
|
|
if (link->irq.active)
|
|
irq = link->irq.active;
|
|
else
|
|
irq = link->irq.possible[link->irq.possible_count - 1];
|
|
|
|
if (acpi_irq_balance || !link->irq.active) {
|
|
/*
|
|
* Select the best IRQ. This is done in reverse to promote
|
|
* the use of IRQs 9, 10, 11, and >15.
|
|
*/
|
|
for (i = (link->irq.possible_count - 1); i >= 0; i--) {
|
|
if (acpi_irq_penalty[irq] >
|
|
acpi_irq_penalty[link->irq.possible[i]])
|
|
irq = link->irq.possible[i];
|
|
}
|
|
}
|
|
|
|
/* Attempt to enable the link device at this IRQ. */
|
|
if (acpi_pci_link_set(link, irq)) {
|
|
printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
|
|
"Try pci=noacpi or acpi=off\n",
|
|
acpi_device_name(link->device),
|
|
acpi_device_bid(link->device));
|
|
return -ENODEV;
|
|
} else {
|
|
acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
|
|
printk(KERN_WARNING PREFIX "%s [%s] enabled at IRQ %d\n",
|
|
acpi_device_name(link->device),
|
|
acpi_device_bid(link->device), link->irq.active);
|
|
}
|
|
|
|
link->irq.initialized = 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* acpi_pci_link_allocate_irq
|
|
* success: return IRQ >= 0
|
|
* failure: return -1
|
|
*/
|
|
int acpi_pci_link_allocate_irq(ACPI_HANDLE handle, int index,
|
|
int *triggering, int *polarity, char **name)
|
|
{
|
|
int result;
|
|
struct acpi_device *device;
|
|
struct acpi_pci_link *link;
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
if (result) {
|
|
printk(KERN_ERR PREFIX "Invalid link device\n");
|
|
return -1;
|
|
}
|
|
|
|
link = acpi_driver_data(device);
|
|
if (!link) {
|
|
printk(KERN_ERR PREFIX "Invalid link context\n");
|
|
return -1;
|
|
}
|
|
|
|
/* TBD: Support multiple index (IRQ) entries per Link Device */
|
|
if (index) {
|
|
printk(KERN_ERR PREFIX "Invalid index %d\n", index);
|
|
return -1;
|
|
}
|
|
|
|
mutex_lock(&acpi_link_lock);
|
|
if (acpi_pci_link_allocate(link)) {
|
|
mutex_unlock(&acpi_link_lock);
|
|
return -1;
|
|
}
|
|
|
|
if (!link->irq.active) {
|
|
mutex_unlock(&acpi_link_lock);
|
|
printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
|
|
return -1;
|
|
}
|
|
link->refcnt++;
|
|
mutex_unlock(&acpi_link_lock);
|
|
|
|
if (triggering)
|
|
*triggering = link->irq.triggering;
|
|
if (polarity)
|
|
*polarity = link->irq.polarity;
|
|
if (name)
|
|
*name = acpi_device_bid(link->device);
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
"Link %s is referenced\n",
|
|
acpi_device_bid(link->device)));
|
|
return (link->irq.active);
|
|
}
|
|
|
|
|