Skip to contentSkip to conversation

Suspend/Resume bug in PCI layer wrt quirks

DISCUSSION Arjan van de Ven 4 participants 9 messages May 15, 2008 – May 19, 2008

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

Hi,

the following is a bug in the PCI layer wrt suspend/resume and quirks:

pci_device_resume_early does the following:

static int pci_device_resume_early(struct device * dev)

{
        int error = 0;
        struct pci_dev * pci_dev = to_pci_dev(dev);
        struct pci_driver * drv = pci_dev->driver; 

        pci_fixup_device(pci_fixup_resume, pci_dev);

eg it calls the resume quirks.

However, one of these quirks is
DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1, asus_hides_smbus_lpc_ich6);

and asus_hides_smbus_lpc_ich6 does

        base = ioremap_nocache(rcba & 0xFFFFC000, 0x4000); /* use bits 31:14, 16 kB aligned */
        if (base == NULL) return;
        val=readl(base + 0x3418); /* read the Function Disable register, dword mode only */
        writel(val & 0xFFFFFFF7, base + 0x3418); /* enable the SMBus device */
        iounmap(base);

internally. ioremap()/iounmap() does a global tlb flush of course, which includes doing an IPI to other cpus. However, during early resume, interrupts are disabled, and it's not allowed to do a IPI/global tlbflush with interrupts off...

This is hitting quite a few people now:
http://www.kerneloops.org/searchweek.php?search=smp_call_function

do we need a DECLARE_PCI_FIXUP_RESUME_LATE() and use that for this one?

#1 lore raw
Quoted 25 lines · Arjan van de Ven

Hi,

the following is a bug in the PCI layer wrt suspend/resume and quirks:

pci_device_resume_early does the following:

static int pci_device_resume_early(struct device * dev)

{
        int error = 0;
        struct pci_dev * pci_dev = to_pci_dev(dev);
        struct pci_driver * drv = pci_dev->driver;

        pci_fixup_device(pci_fixup_resume, pci_dev);

eg it calls the resume quirks.

However, one of these quirks is DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1,
asus_hides_smbus_lpc_ich6);

and asus_hides_smbus_lpc_ich6 does

        base = ioremap_nocache(rcba & 0xFFFFC000, 0x4000); /* use bits
31:14, 16 kB aligned */ if (base == NULL) return;
        val=readl(base + 0x3418); /* read the Function Disable register,
Quoted 7 lines

dword mode only */ writel(val & 0xFFFFFFF7, base + 0x3418); /* enable the SMBus device */ iounmap(base);

internally. ioremap()/iounmap() does a global tlb flush of course, which includes doing an IPI to other cpus. However, during early resume, interrupts are disabled, and it's not allowed to do a IPI/global tlbflush with interrupts off...

Yeah I just got a similar report for quirk_vialatency(). But why are we only seeing these issues now? Is our interrupt disabled check catching more stuff these days?

Rafael said he's looking at the VIA issue, and iirc we had talked about changing this stuff around a few weeks ago anyway. So yeah we may need either a new fixup phase or maybe we can just move the resume fixups to occur a little later, when interrupts are enabled.

Jesse

#2 lore raw

On Thu, 15 May 2008 09:07:06 -0700

Quoted 8 lines
Quoted 4 lines

internally. ioremap()/iounmap() does a global tlb flush of course, which includes doing an IPI to other cpus. However, during early resume, interrupts are disabled, and it's not allowed to do a IPI/global tlbflush with interrupts off...

Yeah I just got a similar report for quirk_vialatency(). But why are we only seeing these issues now? Is our interrupt disabled check catching more stuff these days?

we're now more systematically collecting WARN_ON()'s.....

#3 lore raw
In reply to Jesse Barnes
Quoted 34 lines · Jesse Barnes
Quoted 25 lines · Arjan van de Ven

Hi,

the following is a bug in the PCI layer wrt suspend/resume and quirks:

pci_device_resume_early does the following:

static int pci_device_resume_early(struct device * dev)

{
        int error = 0;
        struct pci_dev * pci_dev = to_pci_dev(dev);
        struct pci_driver * drv = pci_dev->driver;

        pci_fixup_device(pci_fixup_resume, pci_dev);

eg it calls the resume quirks.

However, one of these quirks is DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1,
asus_hides_smbus_lpc_ich6);

and asus_hides_smbus_lpc_ich6 does

        base = ioremap_nocache(rcba & 0xFFFFC000, 0x4000); /* use bits
31:14, 16 kB aligned */ if (base == NULL) return;
        val=readl(base + 0x3418); /* read the Function Disable register,
Quoted 7 lines

dword mode only */ writel(val & 0xFFFFFFF7, base + 0x3418); /* enable the SMBus device */ iounmap(base);

internally. ioremap()/iounmap() does a global tlb flush of course, which includes doing an IPI to other cpus. However, during early resume, interrupts are disabled, and it's not allowed to do a IPI/global tlbflush with interrupts off...

Quoted 8 lines

Yeah I just got a similar report for quirk_vialatency(). But why are we only seeing these issues now? Is our interrupt disabled check catching more stuff these days?

Rafael said he's looking at the VIA issue, and iirc we had talked about changing this stuff around a few weeks ago anyway. So yeah we may need either a new fixup phase or maybe we can just move the resume fixups to occur a little later, when interrupts are enabled.

In fact I forgot about a Shaohua's patch that cleaned up that a bit and is appended (should apply on top of the current -git).

Please have a look and tell me what you think.

Thanks,
Rafael

---

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

---
 drivers/pci/pci-driver.c          |    6 +
 drivers/pci/quirks.c              |  120 +++++++++++++++++++++++++-------------
 include/asm-generic/vmlinux.lds.h |    6 +
 include/linux/pci.h               |   10 ++-
 4 files changed, 102 insertions(+), 40 deletions(-)
drivers/pci/pci-driver.c +5 -1
Index: linux-2.6/drivers/pci/pci-driver.c
===================================================================
@@ -292,6 +292,9 @@ static int pci_device_suspend(struct dev
 		if (pci_dev->current_state == PCI_D0)
 			pci_dev->current_state = PCI_UNKNOWN;
 	}
+
+	pci_fixup_device(pci_fixup_suspend, pci_dev);
+
 	return i;
 }
 
@@ -337,6 +340,7 @@ static int pci_device_resume(struct devi
 		error = drv->resume(pci_dev);
 	else
 		error = pci_default_resume(pci_dev);
+	pci_fixup_device(pci_fixup_resume, pci_dev);
 	return error;
 }
 
@@ -346,7 +350,7 @@ static int pci_device_resume_early(struc
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
 
-	pci_fixup_device(pci_fixup_resume, pci_dev);
+	pci_fixup_device(pci_fixup_resume_early, pci_dev);
 
 	if (drv && drv->resume_early)
 		error = drv->resume_early(pci_dev);
drivers/pci/quirks.c +82 -38

219 lines not on this page · raw message

include/asm-generic/vmlinux.lds.h +6 -0
Index: linux-2.6/include/asm-generic/vmlinux.lds.h
===================================================================
@@ -84,6 +84,12 @@
 		VMLINUX_SYMBOL(__start_pci_fixups_resume) = .;		\
 		*(.pci_fixup_resume)					\
 		VMLINUX_SYMBOL(__end_pci_fixups_resume) = .;		\
+		VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .;	\
+		*(.pci_fixup_resume_early)				\
+		VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .;	\
+		VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .;		\
+		*(.pci_fixup_suspend)					\
+		VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .;		\
 	}								\
 									\
 	/* RapidIO route ops */						\
include/linux/pci.h +9 -1
Index: linux-2.6/include/linux/pci.h
===================================================================
@@ -1013,7 +1013,9 @@ enum pci_fixup_pass {
 	pci_fixup_header,	/* After reading configuration header */
 	pci_fixup_final,	/* Final phase of device fixups */
 	pci_fixup_enable,	/* pci_enable_device() time */
-	pci_fixup_resume,	/* pci_enable_device() time */
+	pci_fixup_resume,	/* pci_device_resume() */
+	pci_fixup_suspend,	/* pci_device_suspend */
+	pci_fixup_resume_early, /* pci_device_resume_early() */
 };
 
 /* Anonymous variables would be nice... */
@@ -1035,6 +1037,12 @@ enum pci_fixup_pass {
 #define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,			\
 			resume##vendor##device##hook, vendor, device, hook)
+#define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook)		\
+	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,		\
+			resume_early##vendor##device##hook, vendor, device, hook)
+#define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook)			\
+	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,			\
+			suspend##vendor##device##hook, vendor, device, hook)
 
 
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
#4 lore raw
Quoted 10 lines · Rafael J. Wysocki

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

I applied this one to linux-next, it should fix some of the problems people have been seeing at least...

Jesse

#5 lore raw
Quoted 6 lines · Jesse Barnes
Quoted 5 lines · Rafael J. Wysocki

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

Quoted 8 lines
Quoted 5 lines

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

I applied this one to linux-next, it should fix some of the problems people have been seeing at least...

Well, that will collide with pm-new-suspend-and-hibernation-callbacks-for-pci-bus-type.patch in the Greg's tree.

Greg, perhaps it's better if you drop it and I'll send an updated version to Jesse? That will make his tree dependent on yours, but that will be okay, won't it?

Thanks,
Rafael

#6 lore raw
Quoted 16 lines · Rafael J. Wysocki
Quoted 6 lines · Jesse Barnes
Quoted 5 lines · Rafael J. Wysocki

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

Quoted 8 lines
Quoted 5 lines

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

I applied this one to linux-next, it should fix some of the problems people have been seeing at least...

Quoted 7 lines

Well, that will collide with pm-new-suspend-and-hibernation-callbacks-for-pci-bus-type.patch in the Greg's tree.

Greg, perhaps it's better if you drop it and I'll send an updated version to Jesse? That will make his tree dependent on yours, but that will be okay, won't it?

That's up to Jesse. I don't know if he can handle a depancy on an external tree.

Jesse?

#7 lore raw
Quoted 21 lines · Greg KH
Quoted 20 lines · Rafael J. Wysocki
Quoted 6 lines · Jesse Barnes
Quoted 5 lines · Rafael J. Wysocki

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

Quoted 8 lines
Quoted 5 lines

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

I applied this one to linux-next, it should fix some of the problems people have been seeing at least...

Well, that will collide with pm-new-suspend-and-hibernation-callbacks-for-pci-bus-type.patch in the Greg's tree.

Quoted 8 lines
Quoted 3 lines

Greg, perhaps it's better if you drop it and I'll send an updated version to Jesse? That will make his tree dependent on yours, but that will be okay, won't it?

That's up to Jesse. I don't know if he can handle a depancy on an external tree.

Jesse?

It would be easiest for me to just carry Rafael's patch, but that assumes you're ok with the changes. Have you looked at it enough to feel good about it, Greg?

Thanks,
Jesse

Acked-by Pavel Machek Acked-by Jesse Barnes
#8 lore raw
Quoted 26 lines · Jesse Barnes
Quoted 25 lines · Greg KH
Quoted 23 lines · Rafael J. Wysocki
Quoted 6 lines · Jesse Barnes
Quoted 5 lines · Rafael J. Wysocki

Some quirks should be called with interrupt disabled, we can't directly call them in .resume_early. Also the patch introduces pci_fixup_resume_early and pci_fixup_suspend, which matches current device core callbacks (.suspend/.resume_early).

Quoted 8 lines
Quoted 5 lines

TBD: Somebody knows why we need quirk resume should double check if a quirk should be called in resume or resume_early. I changed some per my understanding, but can't make sure I fixed all.

I applied this one to linux-next, it should fix some of the problems people have been seeing at least...

Well, that will collide with pm-new-suspend-and-hibernation-callbacks-for-pci-bus-type.patch in the Greg's tree.

Greg, perhaps it's better if you drop it and I'll send an updated version to Jesse? That will make his tree dependent on yours, but that will be okay, won't it?

Quoted 8 lines
Quoted 4 lines

That's up to Jesse. I don't know if he can handle a depancy on an external tree.

Jesse?

It would be easiest for me to just carry Rafael's patch, but that assumes you're ok with the changes. Have you looked at it enough to feel good about it, Greg?

Below is the updated patch, FWIW. It's on top of the Shaohua's patch cleaning up the quirks.

Thanks,
Rafael

---
From: Rafael J. Wysocki <[email protected]>

Implement new suspend and hibernation callbacks for the PCI bus type.

---
 drivers/pci/pci-driver.c |  392 +++++++++++++++++++++++++++++++++++++++++------
 include/linux/pci.h      |    2 
 2 files changed, 347 insertions(+), 47 deletions(-)
drivers/pci/pci-driver.c +346 -46
Index: linux-2.6/drivers/pci/pci-driver.c
===================================================================
@@ -274,7 +274,57 @@ static int pci_device_remove(struct devi
 	return 0;
 }
 
-static int pci_device_suspend(struct device * dev, pm_message_t state)
+static void pci_device_shutdown(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+
+	if (drv && drv->shutdown)
+		drv->shutdown(pci_dev);
+	pci_msi_shutdown(pci_dev);
+	pci_msix_shutdown(pci_dev);
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+/*
+ * Default "suspend" method for devices that have no driver provided suspend,
+ * or not even a driver at all.
+ */
+static void pci_default_pm_suspend(struct pci_dev *pci_dev)
+{
+	pci_save_state(pci_dev);
+	/*
+	 * mark its power state as "unknown", since we don't know if
+	 * e.g. the BIOS will change its device state when we suspend.
+	 */
+	if (pci_dev->current_state == PCI_D0)
+		pci_dev->current_state = PCI_UNKNOWN;
+}
+
+/*
+ * Default "resume" method for devices that have no driver provided resume,
+ * or not even a driver at all.
+ */
+static int pci_default_pm_resume(struct pci_dev *pci_dev)
+{
+	int retval = 0;
+
+	/* restore the PCI config space */
+	pci_restore_state(pci_dev);
+	/* if the device was enabled before suspend, reenable */
+	retval = pci_reenable_device(pci_dev);
+	/*
+	 * if the device was busmaster before the suspend, make it busmaster
+	 * again
+	 */
+	if (pci_dev->is_busmaster)
+		pci_set_master(pci_dev);
+
+	return retval;
+}
+
+static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 {
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
@@ -284,21 +334,12 @@ static int pci_device_suspend(struct dev
 		i = drv->suspend(pci_dev, state);
 		suspend_report_result(drv->suspend, i);
 	} else {
-		pci_save_state(pci_dev);
-		/*
-		 * mark its power state as "unknown", since we don't know if
-		 * e.g. the BIOS will change its device state when we suspend.
-		 */
-		if (pci_dev->current_state == PCI_D0)
-			pci_dev->current_state = PCI_UNKNOWN;
+		pci_default_pm_suspend(pci_dev);
 	}
-
-	pci_fixup_device(pci_fixup_suspend, pci_dev);
-
 	return i;
 }
 
-static int pci_device_suspend_late(struct device * dev, pm_message_t state)
+static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 {
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
@@ -311,26 +352,7 @@ static int pci_device_suspend_late(struc
 	return i;
 }
 
-/*
- * Default resume method for devices that have no driver provided resume,
- * or not even a driver at all.
- */
-static int pci_default_resume(struct pci_dev *pci_dev)
-{
-	int retval = 0;
-
-	/* restore the PCI config space */
-	pci_restore_state(pci_dev);
-	/* if the device was enabled before suspend, reenable */
-	retval = pci_reenable_device(pci_dev);
-	/* if the device was busmaster before the suspend, make it busmaster again */
-	if (pci_dev->is_busmaster)
-		pci_set_master(pci_dev);
-
-	return retval;
-}
-
-static int pci_device_resume(struct device * dev)
+static int pci_legacy_resume(struct device *dev)
 {
 	int error;
 	struct pci_dev * pci_dev = to_pci_dev(dev);
@@ -339,35 +361,313 @@ static int pci_device_resume(struct devi
 	if (drv && drv->resume)
 		error = drv->resume(pci_dev);
 	else
-		error = pci_default_resume(pci_dev);
-	pci_fixup_device(pci_fixup_resume, pci_dev);
+		error = pci_default_pm_resume(pci_dev);
 	return error;
 }
 
-static int pci_device_resume_early(struct device * dev)
+static int pci_legacy_resume_early(struct device *dev)
 {
 	int error = 0;
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
 
-	pci_fixup_device(pci_fixup_resume_early, pci_dev);
-
 	if (drv && drv->resume_early)
 		error = drv->resume_early(pci_dev);
 	return error;
 }
 
-static void pci_device_shutdown(struct device *dev)
+static int pci_pm_prepare(struct device *dev)
+{
+	struct device_driver *drv = dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm && drv->pm->prepare)
+		error = drv->pm->prepare(dev);
+
+	return error;
+}
+
+static void pci_pm_complete(struct device *dev)
+{
+	struct device_driver *drv = dev->driver;
+
+	if (drv && drv->pm && drv->pm->complete)
+		drv->pm->complete(dev);
+}
+
+#ifdef CONFIG_SUSPEND
+
+static int pci_pm_suspend(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->suspend) {
+			error = drv->pm->suspend(dev);
+			suspend_report_result(drv->pm->suspend, error);
+		} else {
+			pci_default_pm_suspend(pci_dev);
+		}
+	} else {
+		error = pci_legacy_suspend(dev, PMSG_SUSPEND);
+	}
+	pci_fixup_device(pci_fixup_suspend, pci_dev);
+
+	return error;
+}
+
+static int pci_pm_suspend_noirq(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
 
-	if (drv && drv->shutdown)
-		drv->shutdown(pci_dev);
-	pci_msi_shutdown(pci_dev);
-	pci_msix_shutdown(pci_dev);
+	if (drv && drv->pm) {
+		if (drv->pm->suspend_noirq) {
+			error = drv->pm->suspend_noirq(dev);
+			suspend_report_result(drv->pm->suspend_noirq, error);
+		}
+	} else {
+		error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
+	}
+
+	return error;
+}
+
+static int pci_pm_resume(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
+	int error;
+
+	pci_fixup_device(pci_fixup_resume, pci_dev);
+
+	if (drv && drv->pm) {
+		error = drv->pm->resume ? drv->pm->resume(dev) :
+			pci_default_pm_resume(pci_dev);
+	} else {
+		error = pci_legacy_resume(dev);
+	}
+
+	return error;
 }
 
+static int pci_pm_resume_noirq(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
+
+	pci_fixup_device(pci_fixup_resume_early, pci_dev);
+
+	if (drv && drv->pm) {
+		if (drv->pm->resume_noirq)
+			error = drv->pm->resume_noirq(dev);
+	} else {
+		error = pci_legacy_resume_early(dev);
+	}
+
+	return error;
+}
+
+#else /* !CONFIG_SUSPEND */
+
+#define pci_pm_suspend		NULL
+#define pci_pm_suspend_noirq	NULL
+#define pci_pm_resume		NULL
+#define pci_pm_resume_noirq	NULL
+
+#endif /* !CONFIG_SUSPEND */
+
+#ifdef CONFIG_HIBERNATION
+
+static int pci_pm_freeze(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->freeze) {
+			error = drv->pm->freeze(dev);
+			suspend_report_result(drv->pm->freeze, error);
+		} else {
+			pci_default_pm_suspend(pci_dev);
+		}
+	} else {
+		error = pci_legacy_suspend(dev, PMSG_FREEZE);
+		pci_fixup_device(pci_fixup_suspend, pci_dev);
+	}
+
+	return error;
+}
+
+static int pci_pm_freeze_noirq(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->freeze_noirq) {
+			error = drv->pm->freeze_noirq(dev);
+			suspend_report_result(drv->pm->freeze_noirq, error);
+		}
+	} else {
+		error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
+	}
+
+	return error;
+}
+
+static int pci_pm_thaw(struct device *dev)
+{
+	struct device_driver *drv = dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->thaw)
+			error =  drv->pm->thaw(dev);
+	} else {
+		pci_fixup_device(pci_fixup_resume, to_pci_dev(dev));
+		error = pci_legacy_resume(dev);
+	}
+
+	return error;
+}
+
+static int pci_pm_thaw_noirq(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->thaw_noirq)
+			error = drv->pm->thaw_noirq(dev);
+	} else {
+		pci_fixup_device(pci_fixup_resume_early, pci_dev);
+		error = pci_legacy_resume_early(dev);
+	}
+
+	return error;
+}
+
+static int pci_pm_poweroff(struct device *dev)
+{
+	struct device_driver *drv = dev->driver;
+	int error = 0;
+
+	pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
+
+	if (drv && drv->pm) {
+		if (drv->pm->poweroff) {
+			error = drv->pm->poweroff(dev);
+			suspend_report_result(drv->pm->poweroff, error);
+		}
+	} else {
+		error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
+	}
+
+	return error;
+}
+
+static int pci_pm_poweroff_noirq(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
+
+	if (drv && drv->pm) {
+		if (drv->pm->poweroff_noirq) {
+			error = drv->pm->poweroff_noirq(dev);
+			suspend_report_result(drv->pm->poweroff_noirq, error);
+		}
+	} else {
+		error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
+	}
+
+	return error;
+}
+
+static int pci_pm_restore(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
+	int error;
+
+	if (drv && drv->pm) {
+		error = drv->pm->restore ? drv->pm->restore(dev) :
+			pci_default_pm_resume(pci_dev);
+	} else {
+		error = pci_legacy_resume(dev);
+	}
+	pci_fixup_device(pci_fixup_resume, pci_dev);
+
+	return error;
+}
+
+static int pci_pm_restore_noirq(struct device *dev)
+{
+	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct pci_driver *drv = pci_dev->driver;
+	int error = 0;
+
+	pci_fixup_device(pci_fixup_resume, pci_dev);
+
+	if (drv && drv->pm) {
+		if (drv->pm->restore_noirq)
+			error = drv->pm->restore_noirq(dev);
+	} else {
+		error = pci_legacy_resume_early(dev);
+	}
+	pci_fixup_device(pci_fixup_resume_early, pci_dev);
+
+	return error;
+}
+
+#else /* !CONFIG_HIBERNATION */
+
+#define pci_pm_freeze		NULL
+#define pci_pm_freeze_noirq	NULL
+#define pci_pm_thaw		NULL
+#define pci_pm_thaw_noirq	NULL
+#define pci_pm_poweroff		NULL
+#define pci_pm_poweroff_noirq	NULL
+#define pci_pm_restore		NULL
+#define pci_pm_restore_noirq	NULL
+
+#endif /* !CONFIG_HIBERNATION */
+
+struct pm_ext_ops pci_pm_ops = {
+	.base = {
+		.prepare = pci_pm_prepare,
+		.complete = pci_pm_complete,
+		.suspend = pci_pm_suspend,
+		.resume = pci_pm_resume,
+		.freeze = pci_pm_freeze,
+		.thaw = pci_pm_thaw,
+		.poweroff = pci_pm_poweroff,
+		.restore = pci_pm_restore,
+	},
+	.suspend_noirq = pci_pm_suspend_noirq,
+	.resume_noirq = pci_pm_resume_noirq,
+	.freeze_noirq = pci_pm_freeze_noirq,
+	.thaw_noirq = pci_pm_thaw_noirq,
+	.poweroff_noirq = pci_pm_poweroff_noirq,
+	.restore_noirq = pci_pm_restore_noirq,
+};
+
+#define PCI_PM_OPS_PTR	&pci_pm_ops
+
+#else /* !CONFIG_PM_SLEEP */
+
+#define PCI_PM_OPS_PTR	NULL
+
+#endif /* !CONFIG_PM_SLEEP */
+
 /**
  * __pci_register_driver - register a new pci driver
  * @drv: the driver structure to register
@@ -390,6 +690,9 @@ int __pci_register_driver(struct pci_dri
 	drv->driver.owner = owner;
 	drv->driver.mod_name = mod_name;
 
+	if (drv->pm)
+		drv->driver.pm = &drv->pm->base;
+
 	spin_lock_init(&drv->dynids.lock);
 	INIT_LIST_HEAD(&drv->dynids.list);
 
@@ -515,12 +818,9 @@ struct bus_type pci_bus_type = {
 	.uevent		= pci_uevent,
 	.probe		= pci_device_probe,
 	.remove		= pci_device_remove,
-	.suspend	= pci_device_suspend,
-	.suspend_late	= pci_device_suspend_late,
-	.resume_early	= pci_device_resume_early,
-	.resume		= pci_device_resume,
 	.shutdown	= pci_device_shutdown,
 	.dev_attrs	= pci_dev_attrs,
+	.pm		= PCI_PM_OPS_PTR,
 };
 
 static int __init pci_driver_init(void)
include/linux/pci.h +1 -1
Index: linux-2.6/include/linux/pci.h
===================================================================
@@ -389,7 +389,7 @@ struct pci_driver {
 	int  (*resume_early) (struct pci_dev *dev);
 	int  (*resume) (struct pci_dev *dev);	                /* Device woken up */
 	void (*shutdown) (struct pci_dev *dev);
-
+	struct pm_ext_ops *pm;
 	struct pci_error_handlers *err_handler;
 	struct device_driver	driver;
 	struct pci_dynids dynids;