iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge ../to-linus

Browse Source
This commit is contained in:
Len Brown 2005-07-29 23:11:11 -04:00
commit dd8f39bbf5
14 changed files with 982 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
View File

@ -442,6 +442,13 @@ acpi_cpufreq_cpu_init (
(u32) data->acpi_data.states[i].transition_latency); (u32) data->acpi_data.states[i].transition_latency);
cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu); cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
/*
* the first call to ->target() should result in us actually
* writing something to the appropriate registers.
*/
data->resume = 1;
return (result); return (result);
err_freqfree: err_freqfree:

1
arch/i386/pci/acpi.c
View File

@ -30,6 +30,7 @@ static int __init pci_acpi_init(void)
acpi_irq_penalty_init(); acpi_irq_penalty_init();
pcibios_scanned++; pcibios_scanned++;
pcibios_enable_irq = acpi_pci_irq_enable; pcibios_enable_irq = acpi_pci_irq_enable;
pcibios_disable_irq = acpi_pci_irq_disable;
if (pci_routeirq) { if (pci_routeirq) {
/* /*

6
arch/i386/pci/common.c
View File

@ -249,3 +249,9 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
return pcibios_enable_irq(dev); return pcibios_enable_irq(dev);
} }
void pcibios_disable_device (struct pci_dev *dev)
{
if (pcibios_disable_irq)
pcibios_disable_irq(dev);
}

1
arch/i386/pci/irq.c
View File

@ -56,6 +56,7 @@ struct irq_router_handler {
}; };
int (*pcibios_enable_irq)(struct pci_dev *dev) = NULL; int (*pcibios_enable_irq)(struct pci_dev *dev) = NULL;
void (*pcibios_disable_irq)(struct pci_dev *dev) = NULL;
/* /*
* Search 0xf0000 -- 0xfffff for the PCI IRQ Routing Table. * Search 0xf0000 -- 0xfffff for the PCI IRQ Routing Table.

1
arch/i386/pci/pci.h
View File

@ -72,3 +72,4 @@ extern int pcibios_scanned;
extern spinlock_t pci_config_lock; extern spinlock_t pci_config_lock;
extern int (*pcibios_enable_irq)(struct pci_dev *dev); extern int (*pcibios_enable_irq)(struct pci_dev *dev);
extern void (*pcibios_disable_irq)(struct pci_dev *dev);

908
drivers/acpi/ec.c
View File

File diff suppressed because it is too large Load Diff

85
drivers/acpi/pci_irq.c
View File

@ -269,7 +269,51 @@ acpi_pci_irq_del_prt (int segment, int bus)
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
PCI Interrupt Routing Support PCI Interrupt Routing Support
-------------------------------------------------------------------------- */ -------------------------------------------------------------------------- */
typedef int (*irq_lookup_func)(struct acpi_prt_entry *, int *, int *, char **);
static int
acpi_pci_allocate_irq(struct acpi_prt_entry *entry,
int *edge_level,
int *active_high_low,
char **link)
{
int irq;
ACPI_FUNCTION_TRACE("acpi_pci_allocate_irq");
if (entry->link.handle) {
irq = acpi_pci_link_allocate_irq(entry->link.handle,
entry->link.index, edge_level, active_high_low, link);
if (irq < 0) {
ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ link routing entry\n"));
return_VALUE(-1);
}
} else {
irq = entry->link.index;
*edge_level = ACPI_LEVEL_SENSITIVE;
*active_high_low = ACPI_ACTIVE_LOW;
}
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
return_VALUE(irq);
}
static int
acpi_pci_free_irq(struct acpi_prt_entry *entry,
int *edge_level,
int *active_high_low,
char **link)
{
int irq;
ACPI_FUNCTION_TRACE("acpi_pci_free_irq");
if (entry->link.handle) {
irq = acpi_pci_link_free_irq(entry->link.handle);
} else {
irq = entry->link.index;
}
return_VALUE(irq);
}
/* /*
* acpi_pci_irq_lookup * acpi_pci_irq_lookup
* success: return IRQ >= 0 * success: return IRQ >= 0
@ -282,12 +326,13 @@ acpi_pci_irq_lookup (
int pin, int pin,
int *edge_level, int *edge_level,
int *active_high_low, int *active_high_low,
char **link) char **link,
irq_lookup_func func)
{ {
struct acpi_prt_entry *entry = NULL; struct acpi_prt_entry *entry = NULL;
int segment = pci_domain_nr(bus); int segment = pci_domain_nr(bus);
int bus_nr = bus->number; int bus_nr = bus->number;
int irq; int ret;
ACPI_FUNCTION_TRACE("acpi_pci_irq_lookup"); ACPI_FUNCTION_TRACE("acpi_pci_irq_lookup");
@ -301,22 +346,8 @@ acpi_pci_irq_lookup (
return_VALUE(-1); return_VALUE(-1);
} }
if (entry->link.handle) { ret = func(entry, edge_level, active_high_low, link);
irq = acpi_pci_link_get_irq(entry->link.handle, return_VALUE(ret);
entry->link.index, edge_level, active_high_low, link);
if (irq < 0) {
ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ link routing entry\n"));
return_VALUE(-1);
}
} else {
irq = entry->link.index;
*edge_level = ACPI_LEVEL_SENSITIVE;
*active_high_low = ACPI_ACTIVE_LOW;
}
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
return_VALUE(irq);
} }
/* /*
@ -330,7 +361,8 @@ acpi_pci_irq_derive (
int pin, int pin,
int *edge_level, int *edge_level,
int *active_high_low, int *active_high_low,
char **link) char **link,
irq_lookup_func func)
{ {
struct pci_dev *bridge = dev; struct pci_dev *bridge = dev;
int irq = -1; int irq = -1;
@ -363,7 +395,7 @@ acpi_pci_irq_derive (
} }
irq = acpi_pci_irq_lookup(bridge->bus, PCI_SLOT(bridge->devfn), irq = acpi_pci_irq_lookup(bridge->bus, PCI_SLOT(bridge->devfn),
pin, edge_level, active_high_low, link); pin, edge_level, active_high_low, link, func);
} }
if (irq < 0) { if (irq < 0) {
@ -415,7 +447,7 @@ acpi_pci_irq_enable (
* values override any BIOS-assigned IRQs set during boot. * values override any BIOS-assigned IRQs set during boot.
*/ */
irq = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin, irq = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
&edge_level, &active_high_low, &link); &edge_level, &active_high_low, &link, acpi_pci_allocate_irq);
/* /*
* If no PRT entry was found, we'll try to derive an IRQ from the * If no PRT entry was found, we'll try to derive an IRQ from the
@ -423,7 +455,7 @@ acpi_pci_irq_enable (
*/ */
if (irq < 0) if (irq < 0)
irq = acpi_pci_irq_derive(dev, pin, &edge_level, irq = acpi_pci_irq_derive(dev, pin, &edge_level,
&active_high_low, &link); &active_high_low, &link, acpi_pci_allocate_irq);
/* /*
* No IRQ known to the ACPI subsystem - maybe the BIOS / * No IRQ known to the ACPI subsystem - maybe the BIOS /
@ -461,7 +493,9 @@ acpi_pci_irq_enable (
EXPORT_SYMBOL(acpi_pci_irq_enable); EXPORT_SYMBOL(acpi_pci_irq_enable);
#ifdef CONFIG_ACPI_DEALLOCATE_IRQ /* FIXME: implement x86/x86_64 version */
void __attribute__((weak)) acpi_unregister_gsi(u32 i) {}
void void
acpi_pci_irq_disable ( acpi_pci_irq_disable (
struct pci_dev *dev) struct pci_dev *dev)
@ -488,14 +522,14 @@ acpi_pci_irq_disable (
* First we check the PCI IRQ routing table (PRT) for an IRQ. * First we check the PCI IRQ routing table (PRT) for an IRQ.
*/ */
gsi = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin, gsi = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
&edge_level, &active_high_low, NULL); &edge_level, &active_high_low, NULL, acpi_pci_free_irq);
/* /*
* If no PRT entry was found, we'll try to derive an IRQ from the * If no PRT entry was found, we'll try to derive an IRQ from the
* device's parent bridge. * device's parent bridge.
*/ */
if (gsi < 0) if (gsi < 0)
gsi = acpi_pci_irq_derive(dev, pin, gsi = acpi_pci_irq_derive(dev, pin,
&edge_level, &active_high_low, NULL); &edge_level, &active_high_low, NULL, acpi_pci_free_irq);
if (gsi < 0) if (gsi < 0)
return_VOID; return_VOID;
@ -511,4 +545,3 @@ acpi_pci_irq_disable (
return_VOID; return_VOID;
} }
#endif /* CONFIG_ACPI_DEALLOCATE_IRQ */

103
drivers/acpi/pci_link.c
View File

@ -68,6 +68,10 @@ static struct acpi_driver acpi_pci_link_driver = {
}, },
}; };
/*
* 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 { struct acpi_pci_link_irq {
u8 active; /* Current IRQ */ u8 active; /* Current IRQ */
u8 edge_level; /* All IRQs */ u8 edge_level; /* All IRQs */
@ -76,8 +80,7 @@ struct acpi_pci_link_irq {
u8 possible_count; u8 possible_count;
u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE]; u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
u8 initialized:1; u8 initialized:1;
u8 suspend_resume:1; u8 reserved:7;
u8 reserved:6;
}; };
struct acpi_pci_link { struct acpi_pci_link {
@ -85,12 +88,14 @@ struct acpi_pci_link {
struct acpi_device *device; struct acpi_device *device;
acpi_handle handle; acpi_handle handle;
struct acpi_pci_link_irq irq; struct acpi_pci_link_irq irq;
int refcnt;
}; };
static struct { static struct {
int count; int count;
struct list_head entries; struct list_head entries;
} acpi_link; } acpi_link;
DECLARE_MUTEX(acpi_link_lock);
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
@ -532,12 +537,12 @@ static int acpi_pci_link_allocate(
ACPI_FUNCTION_TRACE("acpi_pci_link_allocate"); ACPI_FUNCTION_TRACE("acpi_pci_link_allocate");
if (link->irq.suspend_resume) { if (link->irq.initialized) {
acpi_pci_link_set(link, link->irq.active); if (link->refcnt == 0)
link->irq.suspend_resume = 0; /* This means the link is disabled but initialized */
} acpi_pci_link_set(link, link->irq.active);
if (link->irq.initialized)
return_VALUE(0); return_VALUE(0);
}
/* /*
* search for active IRQ in list of possible IRQs. * search for active IRQ in list of possible IRQs.
@ -596,13 +601,13 @@ static int acpi_pci_link_allocate(
} }
/* /*
* acpi_pci_link_get_irq * acpi_pci_link_allocate_irq
* success: return IRQ >= 0 * success: return IRQ >= 0
* failure: return -1 * failure: return -1
*/ */
int int
acpi_pci_link_get_irq ( acpi_pci_link_allocate_irq (
acpi_handle handle, acpi_handle handle,
int index, int index,
int *edge_level, int *edge_level,
@ -613,7 +618,7 @@ acpi_pci_link_get_irq (
struct acpi_device *device = NULL; struct acpi_device *device = NULL;
struct acpi_pci_link *link = NULL; struct acpi_pci_link *link = NULL;
ACPI_FUNCTION_TRACE("acpi_pci_link_get_irq"); ACPI_FUNCTION_TRACE("acpi_pci_link_allocate_irq");
result = acpi_bus_get_device(handle, &device); result = acpi_bus_get_device(handle, &device);
if (result) { if (result) {
@ -633,21 +638,70 @@ acpi_pci_link_get_irq (
return_VALUE(-1); return_VALUE(-1);
} }
if (acpi_pci_link_allocate(link)) down(&acpi_link_lock);
if (acpi_pci_link_allocate(link)) {
up(&acpi_link_lock);
return_VALUE(-1); return_VALUE(-1);
}
if (!link->irq.active) { if (!link->irq.active) {
up(&acpi_link_lock);
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n")); ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n"));
return_VALUE(-1); return_VALUE(-1);
} }
link->refcnt ++;
up(&acpi_link_lock);
if (edge_level) *edge_level = link->irq.edge_level; if (edge_level) *edge_level = link->irq.edge_level;
if (active_high_low) *active_high_low = link->irq.active_high_low; if (active_high_low) *active_high_low = link->irq.active_high_low;
if (name) *name = acpi_device_bid(link->device); 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_VALUE(link->irq.active); return_VALUE(link->irq.active);
} }
/*
* We don't change link's irq information here. After it is reenabled, we
* continue use the info
*/
int
acpi_pci_link_free_irq(acpi_handle handle)
{
struct acpi_device *device = NULL;
struct acpi_pci_link *link = NULL;
acpi_status result;
ACPI_FUNCTION_TRACE("acpi_pci_link_free_irq");
result = acpi_bus_get_device(handle, &device);
if (result) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
return_VALUE(-1);
}
link = (struct acpi_pci_link *) acpi_driver_data(device);
if (!link) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
return_VALUE(-1);
}
down(&acpi_link_lock);
if (!link->irq.initialized) {
up(&acpi_link_lock);
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link isn't initialized\n"));
return_VALUE(-1);
}
link->refcnt --;
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Link %s is dereferenced\n", acpi_device_bid(link->device)));
if (link->refcnt == 0) {
acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
}
up(&acpi_link_lock);
return_VALUE(link->irq.active);
}
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
Driver Interface Driver Interface
-------------------------------------------------------------------------- */ -------------------------------------------------------------------------- */
@ -677,6 +731,7 @@ acpi_pci_link_add (
strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS); strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
acpi_driver_data(device) = link; acpi_driver_data(device) = link;
down(&acpi_link_lock);
result = acpi_pci_link_get_possible(link); result = acpi_pci_link_get_possible(link);
if (result) if (result)
goto end; goto end;
@ -712,6 +767,7 @@ acpi_pci_link_add (
end: end:
/* disable all links -- to be activated on use */ /* disable all links -- to be activated on use */
acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL); acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
up(&acpi_link_lock);
if (result) if (result)
kfree(link); kfree(link);
@ -726,19 +782,32 @@ irqrouter_suspend(
{ {
struct list_head *node = NULL; struct list_head *node = NULL;
struct acpi_pci_link *link = NULL; struct acpi_pci_link *link = NULL;
int ret = 0;
ACPI_FUNCTION_TRACE("irqrouter_suspend"); ACPI_FUNCTION_TRACE("irqrouter_suspend");
list_for_each(node, &acpi_link.entries) { list_for_each(node, &acpi_link.entries) {
link = list_entry(node, struct acpi_pci_link, node); link = list_entry(node, struct acpi_pci_link, node);
if (!link) { if (!link) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n")); ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid link context\n"));
continue; continue;
} }
if (link->irq.active && link->irq.initialized) if (link->irq.initialized && link->refcnt != 0
link->irq.suspend_resume = 1; /* We ignore legacy IDE device irq */
&& link->irq.active != 14 && link->irq.active !=15) {
printk(KERN_WARNING PREFIX
"%d drivers with interrupt %d neglected to call"
" pci_disable_device at .suspend\n",
link->refcnt,
link->irq.active);
printk(KERN_WARNING PREFIX
"Fix the driver, or rmmod before suspend\n");
link->refcnt = 0;
ret = -EINVAL;
}
} }
return_VALUE(0); return_VALUE(ret);
} }
@ -756,8 +825,9 @@ acpi_pci_link_remove (
link = (struct acpi_pci_link *) acpi_driver_data(device); link = (struct acpi_pci_link *) acpi_driver_data(device);
/* TBD: Acquire/release lock */ down(&acpi_link_lock);
list_del(&link->node); list_del(&link->node);
up(&acpi_link_lock);
kfree(link); kfree(link);
@ -849,6 +919,7 @@ int __init acpi_irq_balance_set(char *str)
__setup("acpi_irq_balance", acpi_irq_balance_set); __setup("acpi_irq_balance", acpi_irq_balance_set);
/* FIXME: we will remove this interface after all drivers call pci_disable_device */
static struct sysdev_class irqrouter_sysdev_class = { static struct sysdev_class irqrouter_sysdev_class = {
set_kset_name("irqrouter"), set_kset_name("irqrouter"),
.suspend = irqrouter_suspend, .suspend = irqrouter_suspend,

31
drivers/acpi/processor_idle.c
View File

@ -81,30 +81,33 @@ module_param(bm_history, uint, 0644);
* *
* To skip this limit, boot/load with a large max_cstate limit. * To skip this limit, boot/load with a large max_cstate limit.
*/ */
static int no_c2c3(struct dmi_system_id *id) static int set_max_cstate(struct dmi_system_id *id)
{ {
if (max_cstate > ACPI_PROCESSOR_MAX_POWER) if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
return 0; return 0;
printk(KERN_NOTICE PREFIX "%s detected - C2,C3 disabled." printk(KERN_NOTICE PREFIX "%s detected - %s disabled."
" Override with \"processor.max_cstate=%d\"\n", id->ident, " Override with \"processor.max_cstate=%d\"\n", id->ident,
((int)id->driver_data == 1)? "C2,C3":"C3",
ACPI_PROCESSOR_MAX_POWER + 1); ACPI_PROCESSOR_MAX_POWER + 1);
max_cstate = 1; max_cstate = (int)id->driver_data;
return 0; return 0;
} }
static struct dmi_system_id __initdata processor_power_dmi_table[] = { static struct dmi_system_id __initdata processor_power_dmi_table[] = {
{ no_c2c3, "IBM ThinkPad R40e", { { set_max_cstate, "IBM ThinkPad R40e", {
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }}, DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
{ no_c2c3, "Medion 41700", { { set_max_cstate, "Medion 41700", {
DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J") }}, DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J") }, (void*)1},
{ set_max_cstate, "Clevo 5600D", {
DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307") },
(void*)2},
{}, {},
}; };
@ -549,7 +552,8 @@ static int acpi_processor_get_power_info_default_c1 (struct acpi_processor *pr)
ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1"); ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");
for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++)
memset(pr->power.states, 0, sizeof(struct acpi_processor_cx)); memset(&(pr->power.states[i]), 0,
sizeof(struct acpi_processor_cx));
/* if info is obtained from pblk/fadt, type equals state */ /* if info is obtained from pblk/fadt, type equals state */
pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
@ -580,7 +584,8 @@ static int acpi_processor_get_power_info_cst (struct acpi_processor *pr)
pr->power.count = 0; pr->power.count = 0;
for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++)
memset(pr->power.states, 0, sizeof(struct acpi_processor_cx)); memset(&(pr->power.states[i]), 0,
sizeof(struct acpi_processor_cx));
status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
@ -763,7 +768,6 @@ static void acpi_processor_power_verify_c3(
} }
if (pr->flags.bm_check) { if (pr->flags.bm_check) {
printk("Disabling BM access before entering C3\n");
/* bus mastering control is necessary */ /* bus mastering control is necessary */
if (!pr->flags.bm_control) { if (!pr->flags.bm_control) {
ACPI_DEBUG_PRINT((ACPI_DB_INFO, ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@ -771,7 +775,6 @@ static void acpi_processor_power_verify_c3(
return_VOID; return_VOID;
} }
} else { } else {
printk("Invalidating cache before entering C3\n");
/* /*
* WBINVD should be set in fadt, for C3 state to be * WBINVD should be set in fadt, for C3 state to be
* supported on when bm_check is not required. * supported on when bm_check is not required.
@ -842,7 +845,7 @@ static int acpi_processor_get_power_info (
result = acpi_processor_get_power_info_cst(pr); result = acpi_processor_get_power_info_cst(pr);
if ((result) || (acpi_processor_power_verify(pr) < 2)) { if ((result) || (acpi_processor_power_verify(pr) < 2)) {
result = acpi_processor_get_power_info_fadt(pr); result = acpi_processor_get_power_info_fadt(pr);
if (result) if ((result) || (acpi_processor_power_verify(pr) < 2))
result = acpi_processor_get_power_info_default_c1(pr); result = acpi_processor_get_power_info_default_c1(pr);
} }

63
drivers/net/sk98lin/skge.c
View File

@ -5134,6 +5134,67 @@ static void __devexit skge_remove_one(struct pci_dev *pdev)
kfree(pAC); kfree(pAC);
} }
#ifdef CONFIG_PM
static int skge_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct net_device *dev = pci_get_drvdata(pdev);
DEV_NET *pNet = netdev_priv(dev);
SK_AC *pAC = pNet->pAC;
struct net_device *otherdev = pAC->dev[1];
if (pNet->Up) {
pAC->WasIfUp[0] = SK_TRUE;
DoPrintInterfaceChange = SK_FALSE;
SkDrvDeInitAdapter(pAC, 0); /* performs SkGeClose */
}
if (otherdev != dev) {
pNet = netdev_priv(otherdev);
if (pNet->Up) {
pAC->WasIfUp[1] = SK_TRUE;
DoPrintInterfaceChange = SK_FALSE;
SkDrvDeInitAdapter(pAC, 1); /* performs SkGeClose */
}
}
pci_save_state(pdev);
pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
if (pAC->AllocFlag & SK_ALLOC_IRQ) {
free_irq(dev->irq, dev);
}
pci_disable_device(pdev);
pci_set_power_state(pdev, pci_choose_state(pdev, state));
return 0;
}
static int skge_resume(struct pci_dev *pdev)
{
struct net_device *dev = pci_get_drvdata(pdev);
DEV_NET *pNet = netdev_priv(dev);
SK_AC *pAC = pNet->pAC;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
pci_enable_device(pdev);
pci_set_master(pdev);
if (pAC->GIni.GIMacsFound == 2)
request_irq(dev->irq, SkGeIsr, SA_SHIRQ, pAC->Name, dev);
else
request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, pAC->Name, dev);
if (pAC->WasIfUp[0] == SK_TRUE) {
DoPrintInterfaceChange = SK_FALSE;
SkDrvInitAdapter(pAC, 0); /* first device */
}
if (pAC->dev[1] != dev && pAC->WasIfUp[1] == SK_TRUE) {
DoPrintInterfaceChange = SK_FALSE;
SkDrvInitAdapter(pAC, 1); /* first device */
}
return 0;
}
#endif
static struct pci_device_id skge_pci_tbl[] = { static struct pci_device_id skge_pci_tbl[] = {
{ PCI_VENDOR_ID_3COM, 0x1700, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_3COM, 0x1700, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
{ PCI_VENDOR_ID_3COM, 0x80eb, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_3COM, 0x80eb, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
@ -5159,6 +5220,8 @@ static struct pci_driver skge_driver = {
.id_table = skge_pci_tbl, .id_table = skge_pci_tbl,
.probe = skge_probe_one, .probe = skge_probe_one,
.remove = __devexit_p(skge_remove_one), .remove = __devexit_p(skge_remove_one),
.suspend = skge_suspend,
.resume = skge_resume,
}; };
static int __init skge_init(void) static int __init skge_init(void)

9
drivers/pcmcia/yenta_socket.c
View File

@ -1034,6 +1034,8 @@ static int yenta_dev_suspend (struct pci_dev *dev, pm_message_t state)
pci_read_config_dword(dev, 17*4, &socket->saved_state[1]); pci_read_config_dword(dev, 17*4, &socket->saved_state[1]);
pci_disable_device(dev); pci_disable_device(dev);
free_irq(dev->irq, socket);
/* /*
* Some laptops (IBM T22) do not like us putting the Cardbus * Some laptops (IBM T22) do not like us putting the Cardbus
* bridge into D3. At a guess, some other laptop will * bridge into D3. At a guess, some other laptop will
@ -1059,6 +1061,13 @@ static int yenta_dev_resume (struct pci_dev *dev)
pci_enable_device(dev); pci_enable_device(dev);
pci_set_master(dev); pci_set_master(dev);
if (socket->cb_irq)
if (request_irq(socket->cb_irq, yenta_interrupt,
SA_SHIRQ, "yenta", socket)) {
printk(KERN_WARNING "Yenta: request_irq() failed on resume!\n");
socket->cb_irq = 0;
}
if (socket->type && socket->type->restore_state) if (socket->type && socket->type->restore_state)
socket->type->restore_state(socket); socket->type->restore_state(socket);
} }

3
include/acpi/acpi_drivers.h
View File

@ -56,8 +56,9 @@
/* ACPI PCI Interrupt Link (pci_link.c) */ /* ACPI PCI Interrupt Link (pci_link.c) */
int acpi_irq_penalty_init (void); int acpi_irq_penalty_init (void);
int acpi_pci_link_get_irq (acpi_handle handle, int index, int *edge_level, int acpi_pci_link_allocate_irq (acpi_handle handle, int index, int *edge_level,
int *active_high_low, char **name); int *active_high_low, char **name);
int acpi_pci_link_free_irq(acpi_handle handle);
/* ACPI PCI Interrupt Routing (pci_irq.c) */ /* ACPI PCI Interrupt Routing (pci_irq.c) */

4
include/linux/acpi.h
View File

@ -440,9 +440,7 @@ int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
* If this matches the last registration, any IRQ resources for gsi * If this matches the last registration, any IRQ resources for gsi
* are freed. * are freed.
*/ */
#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
void acpi_unregister_gsi (u32 gsi); void acpi_unregister_gsi (u32 gsi);
#endif
#ifdef CONFIG_ACPI_PCI #ifdef CONFIG_ACPI_PCI
@ -467,9 +465,7 @@ struct pci_dev;
int acpi_pci_irq_enable (struct pci_dev *dev); int acpi_pci_irq_enable (struct pci_dev *dev);
void acpi_penalize_isa_irq(int irq, int active); void acpi_penalize_isa_irq(int irq, int active);
#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
void acpi_pci_irq_disable (struct pci_dev *dev); void acpi_pci_irq_disable (struct pci_dev *dev);
#endif
struct acpi_pci_driver { struct acpi_pci_driver {
struct acpi_pci_driver *next; struct acpi_pci_driver *next;

6
sound/pci/intel8x0.c
View File

@ -2367,6 +2367,8 @@ static int intel8x0_suspend(snd_card_t *card, pm_message_t state)
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (chip->ac97[i]) if (chip->ac97[i])
snd_ac97_suspend(chip->ac97[i]); snd_ac97_suspend(chip->ac97[i]);
if (chip->irq >= 0)
free_irq(chip->irq, (void *)chip);
pci_disable_device(chip->pci); pci_disable_device(chip->pci);
return 0; return 0;
} }
@ -2378,7 +2380,9 @@ static int intel8x0_resume(snd_card_t *card)
pci_enable_device(chip->pci); pci_enable_device(chip->pci);
pci_set_master(chip->pci); pci_set_master(chip->pci);
snd_intel8x0_chip_init(chip, 0); request_irq(chip->irq, snd_intel8x0_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip);
synchronize_irq(chip->irq);
snd_intel8x0_chip_init(chip, 1);
/* refill nocache */ /* refill nocache */
if (chip->fix_nocache) if (chip->fix_nocache)