- linux-2.6-enable-more-pci-autosuspend.patch: Enable more PCI autosuspend

1 files changed, 560 insertions, 0 deletions

diff --git a/linux-2.6-enable-more-pci-autosuspend.patch b/linux-2.6-enable-more-pci-autosuspend.patch
new file mode 100644
index 000000000..b1f92b134
--- /dev/null
+++ b/linux-2.6-enable-more-pci-autosuspend.patch
@@ -0,0 +1,560 @@
+diff -up linux-2.6.35.x86_64/drivers/acpi/acpica/aclocal.h.mjg linux-2.6.35.x86_64/drivers/acpi/acpica/aclocal.h
+--- linux-2.6.35.x86_64/drivers/acpi/acpica/aclocal.h.mjg	2010-10-04 13:52:05.086789354 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/acpica/aclocal.h	2010-10-04 13:52:50.948801001 -0400
+@@ -406,16 +406,15 @@ struct acpi_predefined_data {
+  *
+  ****************************************************************************/
+ 
+-/* Dispatch info for each GPE -- either a method or handler, cannot be both */
++/* Dispatch info for each GPE */
+ 
+ struct acpi_handler_info {
+ 	acpi_event_handler address;	/* Address of handler, if any */
+ 	void *context;		/* Context to be passed to handler */
+-	struct acpi_namespace_node *method_node;	/* Method node for this GPE level (saved) */
+ 	u8 orig_flags;		/* Original misc info about this GPE */
+ };
+ 
+-union acpi_gpe_dispatch_info {
++struct acpi_gpe_dispatch_info {
+ 	struct acpi_namespace_node *method_node;	/* Method node for this GPE level */
+ 	struct acpi_handler_info *handler;
+ };
+@@ -425,7 +424,7 @@ union acpi_gpe_dispatch_info {
+  * NOTE: Important to keep this struct as small as possible.
+  */
+ struct acpi_gpe_event_info {
+-	union acpi_gpe_dispatch_info dispatch;	/* Either Method or Handler */
++	struct acpi_gpe_dispatch_info dispatch;
+ 	struct acpi_gpe_register_info *register_info;	/* Backpointer to register info */
+ 	u8 flags;		/* Misc info about this GPE */
+ 	u8 gpe_number;		/* This GPE */
+diff -up linux-2.6.35.x86_64/drivers/acpi/acpica/evgpe.c.mjg linux-2.6.35.x86_64/drivers/acpi/acpica/evgpe.c
+--- linux-2.6.35.x86_64/drivers/acpi/acpica/evgpe.c.mjg	2010-10-04 13:52:05.088789399 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/acpica/evgpe.c	2010-10-04 13:52:50.950801045 -0400
+@@ -474,9 +474,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_as
+ 	 * Must check for control method type dispatch one more time to avoid a
+ 	 * race with ev_gpe_install_handler
+ 	 */
+-	if ((local_gpe_event_info.flags & ACPI_GPE_DISPATCH_MASK) ==
+-	    ACPI_GPE_DISPATCH_METHOD) {
+-
++	if (local_gpe_event_info.flags & ACPI_GPE_DISPATCH_METHOD) {
+ 		/* Allocate the evaluation information block */
+ 
+ 		info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
+@@ -575,41 +573,15 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_eve
+ 	}
+ 
+ 	/*
+-	 * Dispatch the GPE to either an installed handler, or the control method
+-	 * associated with this GPE (_Lxx or _Exx). If a handler exists, we invoke
+-	 * it and do not attempt to run the method. If there is neither a handler
+-	 * nor a method, we disable this GPE to prevent further such pointless
+-	 * events from firing.
++	 * Dispatch the GPE to either any installed handler or control
++	 * method associated with this GPE (_Lxx or _Exx). We invoke
++	 * the method first in case it has side effects that would be
++	 * interfered with if the handler has already altered hardware
++	 * state. If there is neither a handler nor a method, we
++	 * disable this GPE to prevent further such pointless events
++	 * from firing.
+ 	 */
+-	switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
+-	case ACPI_GPE_DISPATCH_HANDLER:
+-
+-		/*
+-		 * Invoke the installed handler (at interrupt level)
+-		 * Ignore return status for now.
+-		 * TBD: leave GPE disabled on error?
+-		 */
+-		(void)gpe_event_info->dispatch.handler->address(gpe_event_info->
+-								dispatch.
+-								handler->
+-								context);
+-
+-		/* It is now safe to clear level-triggered events. */
+-
+-		if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
+-		    ACPI_GPE_LEVEL_TRIGGERED) {
+-			status = acpi_hw_clear_gpe(gpe_event_info);
+-			if (ACPI_FAILURE(status)) {
+-				ACPI_EXCEPTION((AE_INFO, status,
+-					"Unable to clear GPE[0x%2X]",
+-						gpe_number));
+-				return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
+-			}
+-		}
+-		break;
+-
+-	case ACPI_GPE_DISPATCH_METHOD:
+-
++	if (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD) {
+ 		/*
+ 		 * Disable the GPE, so it doesn't keep firing before the method has a
+ 		 * chance to run (it runs asynchronously with interrupts enabled).
+@@ -634,10 +606,34 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_eve
+ 					"Unable to queue handler for GPE[0x%2X] - event disabled",
+ 					gpe_number));
+ 		}
+-		break;
++	}
+ 
+-	default:
++	if (gpe_event_info->flags & ACPI_GPE_DISPATCH_HANDLER) {
++		/*
++		 * Invoke the installed handler (at interrupt level)
++		 * Ignore return status for now.
++		 * TBD: leave GPE disabled on error?
++		 */
++		(void)gpe_event_info->dispatch.handler->address(gpe_event_info->
++								dispatch.
++								handler->
++								context);
++
++		/* It is now safe to clear level-triggered events. */
++
++		if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
++		    ACPI_GPE_LEVEL_TRIGGERED) {
++			status = acpi_hw_clear_gpe(gpe_event_info);
++			if (ACPI_FAILURE(status)) {
++				ACPI_EXCEPTION((AE_INFO, status,
++					"Unable to clear GPE[0x%2X]",
++						gpe_number));
++				return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
++			}
++		}
++	}
+ 
++	if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)) {
+ 		/*
+ 		 * No handler or method to run!
+ 		 * 03/2010: This case should no longer be possible. We will not allow
+@@ -658,7 +654,6 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_eve
+ 					gpe_number));
+ 			return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
+ 		}
+-		break;
+ 	}
+ 
+ 	return_UINT32(ACPI_INTERRUPT_HANDLED);
+diff -up linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeinit.c.mjg linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeinit.c
+--- linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeinit.c.mjg	2010-10-04 13:52:05.089789421 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeinit.c	2010-10-04 13:52:50.951801067 -0400
+@@ -392,16 +392,7 @@ acpi_ev_match_gpe_method(acpi_handle obj
+ 		return_ACPI_STATUS(AE_OK);
+ 	}
+ 
+-	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
+-	    ACPI_GPE_DISPATCH_HANDLER) {
+-
+-		/* If there is already a handler, ignore this GPE method */
+-
+-		return_ACPI_STATUS(AE_OK);
+-	}
+-
+-	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
+-	    ACPI_GPE_DISPATCH_METHOD) {
++	if (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD) {
+ 		/*
+ 		 * If there is already a method, ignore this method. But check
+ 		 * for a type mismatch (if both the _Lxx AND _Exx exist)
+diff -up linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeutil.c.mjg linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeutil.c
+--- linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeutil.c.mjg	2010-10-04 13:52:05.090789443 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/acpica/evgpeutil.c	2010-10-04 13:52:50.952801089 -0400
+@@ -323,12 +323,11 @@ acpi_ev_delete_gpe_handlers(struct acpi_
+ 								 ACPI_GPE_REGISTER_WIDTH)
+ 								+ j];
+ 
+-			if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
+-			    ACPI_GPE_DISPATCH_HANDLER) {
++			if (gpe_event_info->flags & ACPI_GPE_DISPATCH_HANDLER) {
+ 				ACPI_FREE(gpe_event_info->dispatch.handler);
+ 				gpe_event_info->dispatch.handler = NULL;
+ 				gpe_event_info->flags &=
+-				    ~ACPI_GPE_DISPATCH_MASK;
++				    ~ACPI_GPE_DISPATCH_HANDLER;
+ 			}
+ 		}
+ 	}
+diff -up linux-2.6.35.x86_64/drivers/acpi/acpica/evxface.c.mjg linux-2.6.35.x86_64/drivers/acpi/acpica/evxface.c
+--- linux-2.6.35.x86_64/drivers/acpi/acpica/evxface.c.mjg	2010-10-04 13:52:05.092789487 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/acpica/evxface.c	2010-10-04 13:52:50.954801133 -0400
+@@ -662,6 +662,8 @@ ACPI_EXPORT_SYMBOL(acpi_remove_notify_ha
+  *                                edge- or level-triggered interrupt.
+  *              Address         - Address of the handler
+  *              Context         - Value passed to the handler on each GPE
++ *		keep_method	- Whether the existing method should be
++ *				  displaced or kept
+  *
+  * RETURN:      Status
+  *
+@@ -671,7 +673,8 @@ ACPI_EXPORT_SYMBOL(acpi_remove_notify_ha
+ acpi_status
+ acpi_install_gpe_handler(acpi_handle gpe_device,
+ 			 u32 gpe_number,
+-			 u32 type, acpi_event_handler address, void *context)
++			 u32 type, acpi_event_handler address, void *context,
++			 bool keep_method)
+ {
+ 	struct acpi_gpe_event_info *gpe_event_info;
+ 	struct acpi_handler_info *handler;
+@@ -711,8 +714,7 @@ acpi_install_gpe_handler(acpi_handle gpe
+ 
+ 	/* Make sure that there isn't a handler there already */
+ 
+-	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
+-	    ACPI_GPE_DISPATCH_HANDLER) {
++	if (gpe_event_info->flags & ACPI_GPE_DISPATCH_HANDLER) {
+ 		status = AE_ALREADY_EXISTS;
+ 		goto free_and_exit;
+ 	}
+@@ -721,7 +723,6 @@ acpi_install_gpe_handler(acpi_handle gpe
+ 
+ 	handler->address = address;
+ 	handler->context = context;
+-	handler->method_node = gpe_event_info->dispatch.method_node;
+ 	handler->orig_flags = gpe_event_info->flags &
+ 			(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+ 
+@@ -733,17 +734,17 @@ acpi_install_gpe_handler(acpi_handle gpe
+ 	 */
+ 
+ 	if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD)
+-	    && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE))
++	    && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE) && !keep_method)
+ 		(void)acpi_raw_disable_gpe(gpe_event_info);
+ 
+ 	/* Install the handler */
+ 
+ 	gpe_event_info->dispatch.handler = handler;
+ 
+-	/* Setup up dispatch flags to indicate handler (vs. method) */
++	if (!keep_method)
++		gpe_event_info->flags &=
++			~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+ 
+-	gpe_event_info->flags &=
+-	    ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+ 	gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER);
+ 
+ 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+@@ -812,8 +813,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_
+ 
+ 	/* Make sure that a handler is indeed installed */
+ 
+-	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
+-	    ACPI_GPE_DISPATCH_HANDLER) {
++	if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_HANDLER)) {
+ 		status = AE_NOT_EXIST;
+ 		goto unlock_and_exit;
+ 	}
+@@ -829,9 +829,8 @@ acpi_remove_gpe_handler(acpi_handle gpe_
+ 
+ 	handler = gpe_event_info->dispatch.handler;
+ 
+-	/* Restore Method node (if any), set dispatch flags */
++	/* Set dispatch flags */
+ 
+-	gpe_event_info->dispatch.method_node = handler->method_node;
+ 	gpe_event_info->flags &=
+ 		~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+ 	gpe_event_info->flags |= handler->orig_flags;
+diff -up linux-2.6.35.x86_64/drivers/acpi/ec.c.mjg linux-2.6.35.x86_64/drivers/acpi/ec.c
+--- linux-2.6.35.x86_64/drivers/acpi/ec.c.mjg	2010-10-04 13:52:05.094789531 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/ec.c	2010-10-04 13:52:50.955801156 -0400
+@@ -746,7 +746,7 @@ static int ec_install_handlers(struct ac
+ 		return 0;
+ 	status = acpi_install_gpe_handler(NULL, ec->gpe,
+ 				  ACPI_GPE_EDGE_TRIGGERED,
+-				  &acpi_ec_gpe_handler, ec);
++				  &acpi_ec_gpe_handler, ec, false);
+ 	if (ACPI_FAILURE(status))
+ 		return -ENODEV;
+ 
+diff -up linux-2.6.35.x86_64/drivers/acpi/pci_bind.c.mjg linux-2.6.35.x86_64/drivers/acpi/pci_bind.c
+--- linux-2.6.35.x86_64/drivers/acpi/pci_bind.c.mjg	2010-10-04 13:52:05.102789707 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/pci_bind.c	2010-10-04 13:52:50.962801311 -0400
+@@ -28,6 +28,7 @@
+ #include <linux/pci.h>
+ #include <linux/pci-acpi.h>
+ #include <linux/acpi.h>
++#include <linux/list.h>
+ #include <linux/pm_runtime.h>
+ #include <acpi/acpi_bus.h>
+ #include <acpi/acpi_drivers.h>
+@@ -35,6 +36,43 @@
+ #define _COMPONENT		ACPI_PCI_COMPONENT
+ ACPI_MODULE_NAME("pci_bind");
+ 
++static LIST_HEAD(acpi_pci_gpe_devs);
++
++struct pci_gpe_dev {
++	struct list_head node;
++	struct pci_dev *dev;
++	acpi_handle gpe_device;
++	int gpe_number;
++	struct work_struct work;
++};
++
++static void acpi_pci_wake_handler_work(struct work_struct *work)
++{
++	struct pci_gpe_dev *gpe_dev = container_of(work, struct pci_gpe_dev,
++						   work);
++
++	pci_check_pme_status(gpe_dev->dev);
++	pm_runtime_resume(&gpe_dev->dev->dev);
++	pci_wakeup_event(gpe_dev->dev);
++	if (gpe_dev->dev->subordinate)
++		pci_pme_wakeup_bus(gpe_dev->dev->subordinate);
++}
++
++static u32 acpi_pci_wake_handler(void *data)
++{
++	long gpe_number = (long) data;
++	struct pci_gpe_dev *gpe_dev;
++
++	list_for_each_entry(gpe_dev, &acpi_pci_gpe_devs, node) {
++		if (gpe_number != gpe_dev->gpe_number)
++			continue;
++
++		schedule_work(&gpe_dev->work);
++	}
++
++	return ACPI_INTERRUPT_HANDLED;
++}
++
+ static int acpi_pci_unbind(struct acpi_device *device)
+ {
+ 	struct pci_dev *dev;
+@@ -43,6 +81,30 @@ static int acpi_pci_unbind(struct acpi_d
+ 	if (!dev)
+ 		goto out;
+ 
++	if (device->wakeup.flags.valid) {
++		struct pci_gpe_dev *gpe_dev;
++		struct pci_gpe_dev *tmp;
++		int gpe_count = 0;
++		int gpe_number = device->wakeup.gpe_number;
++		acpi_handle gpe_device = device->wakeup.gpe_device;
++
++		list_for_each_entry_safe(gpe_dev, tmp, &acpi_pci_gpe_devs, node) {
++			if (gpe_dev->dev == dev) {
++				flush_work(&gpe_dev->work);
++				list_del(&gpe_dev->node);
++				kfree(gpe_dev);
++			} else if (gpe_dev->gpe_number == gpe_number &&
++				   gpe_dev->gpe_device == gpe_device) {
++				gpe_count++;
++			}
++		}
++
++		if (gpe_count == 0) {
++			acpi_remove_gpe_handler(gpe_device, gpe_number,
++						&acpi_pci_wake_handler);
++		}
++	}
++
+ 	device_set_run_wake(&dev->dev, false);
+ 	pci_acpi_remove_pm_notifier(device);
+ 
+@@ -71,6 +133,30 @@ static int acpi_pci_bind(struct acpi_dev
+ 		return 0;
+ 
+ 	pci_acpi_add_pm_notifier(device, dev);
++	if (device->wakeup.flags.valid) {
++		struct pci_gpe_dev *gpe_dev;
++		acpi_handle gpe_device = device->wakeup.gpe_device;
++		long gpe_number = device->wakeup.gpe_number;
++
++		gpe_dev = kmalloc(sizeof(struct pci_gpe_dev), GFP_KERNEL);
++		if (gpe_dev) {
++			gpe_dev->dev = dev;
++			gpe_dev->gpe_device = gpe_device;
++			gpe_dev->gpe_number = gpe_number;
++			INIT_WORK(&gpe_dev->work, acpi_pci_wake_handler_work);
++
++			acpi_install_gpe_handler(gpe_device, gpe_number,
++						 ACPI_GPE_LEVEL_TRIGGERED,
++						 &acpi_pci_wake_handler,
++						 (void *)gpe_number,
++						 true);
++			acpi_gpe_can_wake(device->wakeup.gpe_device,
++					  device->wakeup.gpe_number);
++			device->wakeup.flags.run_wake = 1;
++			list_add_tail(&gpe_dev->node, &acpi_pci_gpe_devs);
++		}
++	}
++
+ 	if (device->wakeup.flags.run_wake)
+ 		device_set_run_wake(&dev->dev, true);
+ 
+diff -up linux-2.6.35.x86_64/drivers/acpi/sleep.c.mjg linux-2.6.35.x86_64/drivers/acpi/sleep.c
+--- linux-2.6.35.x86_64/drivers/acpi/sleep.c.mjg	2010-10-04 13:52:05.103789729 -0400
++++ linux-2.6.35.x86_64/drivers/acpi/sleep.c	2010-10-04 13:52:50.963801333 -0400
+@@ -631,9 +631,9 @@ int acpi_pm_device_sleep_state(struct de
+ 		acpi_method[3] = 'W';
+ 		status = acpi_evaluate_integer(handle, acpi_method, NULL,
+ 						&d_max);
+-		if (ACPI_FAILURE(status)) {
++		if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+ 			d_max = d_min;
+-		} else if (d_max < d_min) {
++		} else if (ACPI_SUCCESS(status) && d_max < d_min) {
+ 			/* Warn the user of the broken DSDT */
+ 			printk(KERN_WARNING "ACPI: Wrong value from %s\n",
+ 				acpi_method);
+diff -up linux-2.6.35.x86_64/drivers/char/ipmi/ipmi_si_intf.c.mjg linux-2.6.35.x86_64/drivers/char/ipmi/ipmi_si_intf.c
+--- linux-2.6.35.x86_64/drivers/char/ipmi/ipmi_si_intf.c.mjg	2010-10-04 13:52:05.097789597 -0400
++++ linux-2.6.35.x86_64/drivers/char/ipmi/ipmi_si_intf.c	2010-10-04 13:52:50.958801223 -0400
+@@ -1959,7 +1959,7 @@ static int acpi_gpe_irq_setup(struct smi
+ 					  info->irq,
+ 					  ACPI_GPE_LEVEL_TRIGGERED,
+ 					  &ipmi_acpi_gpe,
+-					  info);
++					  info, false);
+ 	if (status != AE_OK) {
+ 		dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
+ 			 " running polled\n", DEVICE_NAME, info->irq);
+diff -up linux-2.6.35.x86_64/drivers/pci/pci.c.mjg linux-2.6.35.x86_64/drivers/pci/pci.c
+--- linux-2.6.35.x86_64/drivers/pci/pci.c.mjg	2010-10-04 13:52:05.105789773 -0400
++++ linux-2.6.35.x86_64/drivers/pci/pci.c	2010-10-04 13:52:50.965801377 -0400
+@@ -38,6 +38,19 @@ EXPORT_SYMBOL(pci_pci_problems);
+ 
+ unsigned int pci_pm_d3_delay;
+ 
++static void pci_pme_list_scan(struct work_struct *work);
++
++static LIST_HEAD(pci_pme_list);
++static DEFINE_MUTEX(pci_pme_list_mutex);
++static DECLARE_DELAYED_WORK(pci_pme_work, pci_pme_list_scan);
++
++struct pci_pme_device {
++	struct list_head list;
++	struct pci_dev *dev;
++};
++
++#define PME_TIMEOUT 1000 /* How long between PME checks */
++
+ static void pci_dev_d3_sleep(struct pci_dev *dev)
+ {
+ 	unsigned int delay = dev->d3_delay;
+@@ -1331,6 +1344,32 @@ bool pci_pme_capable(struct pci_dev *dev
+ 	return !!(dev->pme_support & (1 << state));
+ }
+ 
++static void pci_pme_list_scan(struct work_struct *work)
++{
++	struct pci_pme_device *pme_dev;
++
++	mutex_lock(&pci_pme_list_mutex);
++	if (!list_empty(&pci_pme_list)) {
++		list_for_each_entry(pme_dev, &pci_pme_list, list)
++			pci_pme_wakeup(pme_dev->dev, NULL);
++		schedule_delayed_work(&pci_pme_work, msecs_to_jiffies(PME_TIMEOUT));
++	}
++	mutex_unlock(&pci_pme_list_mutex);
++}
++
++/**
++ * pci_external_pme - is a device an external PCI PME source?
++ * @dev: PCI device to check
++ *
++ */
++
++static bool pci_external_pme(struct pci_dev *dev)
++{
++	if (pci_is_pcie(dev) || dev->bus->number == 0)
++		return false;
++	return true;
++}
++
+ /**
+  * pci_pme_active - enable or disable PCI device's PME# function
+  * @dev: PCI device to handle.
+@@ -1354,6 +1393,44 @@ void pci_pme_active(struct pci_dev *dev,
+ 
+ 	pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
+ 
++	/* PCI (as opposed to PCIe) PME requires that the device have
++	   its PME# line hooked up correctly. Not all hardware vendors
++	   do this, so the PME never gets delivered and the device
++	   remains asleep. The easiest way around this is to
++	   periodically walk the list of suspended devices and check
++	   whether any have their PME flag set. The assumption is that
++	   we'll wake up often enough anyway that this won't be a huge
++	   hit, and the power savings from the devices will still be a
++	   win. */
++
++	if (pci_external_pme(dev)) {
++		struct pci_pme_device *pme_dev;
++		if (enable) {
++			pme_dev = kmalloc(sizeof(struct pci_pme_device),
++					  GFP_KERNEL);
++			if (!pme_dev)
++				goto out;
++			pme_dev->dev = dev;
++			mutex_lock(&pci_pme_list_mutex);
++			list_add(&pme_dev->list, &pci_pme_list);
++			if (list_is_singular(&pci_pme_list))
++				schedule_delayed_work(&pci_pme_work,
++						      msecs_to_jiffies(PME_TIMEOUT));
++			mutex_unlock(&pci_pme_list_mutex);
++		} else {
++			mutex_lock(&pci_pme_list_mutex);
++			list_for_each_entry(pme_dev, &pci_pme_list, list) {
++				if (pme_dev->dev == dev) {
++					list_del(&pme_dev->list);
++					kfree(pme_dev);
++					break;
++				}
++			}
++			mutex_unlock(&pci_pme_list_mutex);
++		}
++	}
++
++out:
+ 	dev_printk(KERN_DEBUG, &dev->dev, "PME# %s\n",
+ 			enable ? "enabled" : "disabled");
+ }
+diff -up linux-2.6.35.x86_64/drivers/pci/pci.h.mjg linux-2.6.35.x86_64/drivers/pci/pci.h
+--- linux-2.6.35.x86_64/drivers/pci/pci.h.mjg	2010-10-04 13:52:05.100789663 -0400
++++ linux-2.6.35.x86_64/drivers/pci/pci.h	2010-10-04 13:52:50.960801267 -0400
+@@ -63,11 +63,8 @@ struct pci_platform_pm_ops {
+ extern int pci_set_platform_pm(struct pci_platform_pm_ops *ops);
+ extern void pci_update_current_state(struct pci_dev *dev, pci_power_t state);
+ extern void pci_disable_enabled_device(struct pci_dev *dev);
+-extern bool pci_check_pme_status(struct pci_dev *dev);
+ extern int pci_finish_runtime_suspend(struct pci_dev *dev);
+-extern void pci_wakeup_event(struct pci_dev *dev);
+ extern int __pci_pme_wakeup(struct pci_dev *dev, void *ign);
+-extern void pci_pme_wakeup_bus(struct pci_bus *bus);
+ extern void pci_pm_init(struct pci_dev *dev);
+ extern void platform_pci_wakeup_init(struct pci_dev *dev);
+ extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
+diff -up linux-2.6.35.x86_64/include/acpi/acpixf.h.mjg linux-2.6.35.x86_64/include/acpi/acpixf.h
+--- linux-2.6.35.x86_64/include/acpi/acpixf.h.mjg	2010-10-04 13:52:05.099789641 -0400
++++ linux-2.6.35.x86_64/include/acpi/acpixf.h	2010-10-04 13:52:50.959801245 -0400
+@@ -253,7 +253,8 @@ acpi_remove_address_space_handler(acpi_h
+ acpi_status
+ acpi_install_gpe_handler(acpi_handle gpe_device,
+ 			 u32 gpe_number,
+-			 u32 type, acpi_event_handler address, void *context);
++			 u32 type, acpi_event_handler address, void *context,
++			 bool keep_method);
+ 
+ acpi_status
+ acpi_remove_gpe_handler(acpi_handle gpe_device,
+diff -up linux-2.6.35.x86_64/include/linux/pci.h.mjg linux-2.6.35.x86_64/include/linux/pci.h
+--- linux-2.6.35.x86_64/include/linux/pci.h.mjg	2010-10-04 13:52:05.101789685 -0400
++++ linux-2.6.35.x86_64/include/linux/pci.h	2010-10-04 13:52:50.962801311 -0400
+@@ -819,6 +819,9 @@ pci_power_t pci_target_state(struct pci_
+ int pci_prepare_to_sleep(struct pci_dev *dev);
+ int pci_back_from_sleep(struct pci_dev *dev);
+ bool pci_dev_run_wake(struct pci_dev *dev);
++bool pci_check_pme_status(struct pci_dev *dev);
++void pci_wakeup_event(struct pci_dev *dev);
++void pci_pme_wakeup_bus(struct pci_bus *bus);
+ 
+ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
+ 				  bool enable)