diff -ruNp 840-core-driver-model-old/kernel/power/suspend2_core/driver_model.c 840-core-driver-model-new/kernel/power/suspend2_core/driver_model.c
--- 840-core-driver-model-old/kernel/power/suspend2_core/driver_model.c	2004-12-24 10:39:30.608413672 +1100
+++ 840-core-driver-model-new/kernel/power/suspend2_core/driver_model.c	2004-12-24 09:22:42.281985776 +1100
@@ -24,165 +24,80 @@ static int suspend_acpi_state_used = 0;
 extern struct pm_ops * pm_ops;
 static u32 pm_disk_mode_save;
 
-struct partial_device_tree * suspend_device_tree;
-EXPORT_SYMBOL_GPL(suspend_device_tree);
-
 
 #ifdef CONFIG_ACPI
 extern u32 acpi_leave_sleep_state (u8 sleep_state);
 #endif
 
-void suspend_drivers_resume(int stage)
-{
-	switch (stage) {
-		case SUSPEND_DRIVERS_USED_DEVICES_IRQS_DISABLED:
-			BUG_ON(!irqs_disabled());
-			if (!TEST_ACTION_STATE(SUSPEND_DISABLE_SYSDEV_SUPPORT))
-				sysdev_resume();
-			dpm_power_up_tree(suspend_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_USED_DEVICES_IRQS_ENABLED:
-			BUG_ON(irqs_disabled());
-			device_resume_tree(suspend_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_UNUSED_DEVICES_IRQS_DISABLED:
-			BUG_ON(!irqs_disabled());
-			dpm_power_up_tree(&default_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_UNUSED_DEVICES_IRQS_ENABLED:
-			BUG_ON(irqs_disabled());
-			device_resume_tree(&default_device_tree);
-#ifdef CONFIG_ACPI
-			if (suspend_acpi_state_used)
-				acpi_leave_sleep_state(suspend_acpi_state_used);
-#endif
-			device_resume_tree(&default_device_tree);
-#ifdef CONFIG_ACPI
-			if (suspend_acpi_state_used &&
-				pm_ops && pm_ops->finish)
-				pm_ops->finish(suspend_acpi_state_used);
-#endif
-			break;
-	}
-}
-
-/*	suspend_drivers_suspend
- *	@stage - one of:
- *		1: Power down drivers not used in writing the image
- *		2: Quiesce drivers used in writing the image
- *		   (prior to making atomic copy)
- *		3: Power down drivers used in writing the image and
- *		   enter the suspend mode if configured to do so.
- *
- */
-int suspend_drivers_suspend(int stage)
-{
-	int result = 0;
-
-	switch (stage) {
-		case SUSPEND_DRIVERS_UNUSED_DEVICES_IRQS_DISABLED:
-			BUG_ON(!irqs_disabled());
-			result = device_power_down_tree(
-				PM_SUSPEND_DISK, &default_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_UNUSED_DEVICES_IRQS_ENABLED:
-			BUG_ON(irqs_disabled());
-			result = device_suspend_tree(
-					PM_SUSPEND_DISK, &default_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_USED_DEVICES_IRQS_DISABLED:
-			BUG_ON(!irqs_disabled());
-			result = device_power_down_tree(PM_SUSPEND_DISK, suspend_device_tree);
-			if (!TEST_ACTION_STATE(SUSPEND_DISABLE_SYSDEV_SUPPORT))
-				sysdev_suspend(PM_SUSPEND_DISK);
-			break;
-
-		case SUSPEND_DRIVERS_USED_DEVICES_IRQS_ENABLED:
-			BUG_ON(irqs_disabled());
-			result = device_suspend_tree(
-					PM_SUSPEND_DISK, suspend_device_tree);
-			break;
-
-		case SUSPEND_DRIVERS_PRE_POWERDOWN: /* Power down system */
-			BUG_ON(irqs_disabled());
-			break;
-	}
-	return result;
-}
-
 void suspend_drivers_cleanup(void)
 {
 	if (pm_ops) pm_ops->pm_disk_mode = pm_disk_mode_save;
-			
-	if (suspend_device_tree) {
-		device_merge_tree(suspend_device_tree, &default_device_tree);
-		device_destroy_tree(suspend_device_tree);
-		suspend_device_tree = NULL;
-	}
 }
 
 int suspend_drivers_init(void)
 {
-	struct class * class;
-	struct class_device * class_dev;
-
 	if (pm_ops) {
 		pm_disk_mode_save = pm_ops->pm_disk_mode;
 		pm_ops->pm_disk_mode = PM_DISK_PLATFORM;
 	}
 			
-	BUG_ON(suspend_device_tree);
-	suspend_device_tree = device_create_tree();
-	if (IS_ERR(suspend_device_tree)) {
-		suspend_device_tree = NULL;
-		return -ENOMEM;
-	}
-	
-	/* Now check for graphics class devices, so we can keep the display on while suspending */
-	class = class_find("graphics");
-	if (class) {
-		list_for_each_entry(class_dev, &class->children, node)
-			device_switch_trees(class_dev->dev, suspend_device_tree);
-		class_put(class);
-	}
-
 	return 0;
 }
 
-static void suspend_enter_acpi_state(u32 state)
+static int suspend_enter_acpi_state(u32 state)
 {
+	int ret = 0;
+	unsigned long flags;
 	suspend_acpi_state_used = state;
 
-	if (pm_ops && pm_ops->prepare) {
-		if (!pm_ops->prepare(state)) {
-			if (pm_ops && pm_ops->enter)
-				pm_ops->enter(state);
-			else 
-				printk("Failed to enter state.\n");
-		} else
-			printk("Prepare ops failed.\n");
-	} else
-		printk("No prepare ops.\n");
-}
+	local_irq_save(flags);
+	device_power_down(state);
+	if (pm_ops && pm_ops->enter)
+		ret = pm_ops->enter(state);
+	else 
+		printk("Failed to enter state.\n");
+
+	device_power_up();
+	local_irq_restore(flags);
 
-extern asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg);
+	return ret;
+}
 
 static void suspend_power_off(void)
 {
-	sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
-			LINUX_REBOOT_CMD_POWER_OFF, NULL);
-
+	machine_power_off();
 	prepare_status(1, 0, "Probably not capable for powerdown.");
 	while (1)
 		cpu_relax();
 	/* NOTREACHED */
 }
 
+int suspend_power_down_prepare(void)
+{
+	int ret = 0;
+	
+	if (suspend_powerdown_method == 3 ||
+	    suspend_powerdown_method == 4)
+		if (pm_ops && pm_ops->prepare)
+			ret = pm_ops->prepare(suspend_powerdown_method);
+
+	return ret;
+}
+
+int suspend_power_down_finish(void)
+{
+	int ret = 0;
+
+	device_resume();
+
+#ifdef CONFIG_ACPI
+	if (suspend_acpi_state_used && pm_ops && pm_ops->finish)
+		ret = pm_ops->finish(suspend_acpi_state_used);
+#endif
+
+	return ret;
+}
+
 /*
  * suspend_power_down
  * Functionality   : Powers down or reboots the computer once the image
@@ -199,28 +114,86 @@ void suspend_power_down(void)
 {
 	if (TEST_ACTION_STATE(SUSPEND_REBOOT)) {
 		prepare_status(1, 0, "Ready to reboot.");
-		sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
-				LINUX_REBOOT_CMD_RESTART, NULL);
+		device_shutdown();
+		machine_restart(NULL);
 	}
 
-	suspend_drivers_suspend(SUSPEND_DRIVERS_PRE_POWERDOWN);
-
-	if (suspend_powerdown_method == 3) {
-		prepare_status(1, 0, "Seeking to suspend-to-ram.");
-		suspend_enter_acpi_state(PM_SUSPEND_MEM);
-		prepare_status(1, 0, "Entering S3 failed. Using normal powerdown.");
-	} else if (suspend_powerdown_method == 4) {
-		prepare_status(1, 0, "Seeking to enter ACPI suspend-to-disk state.");
-		suspend_enter_acpi_state(PM_SUSPEND_DISK);
-		prepare_status(1, 0, "Entering S4 failed. Using normal powerdown.");
+	if (suspend_powerdown_method >= 3 && suspend_powerdown_method <= 4) {
+		prepare_status(1, 0, "Seeking to enter ACPI state");
+		if (suspend_power_down_prepare()) {
+			prepare_status(1, 0, "Preparing to enter ACPI state failed. Using normal powerdown.");
+			goto abort_ACPI_sleep;
+		}
+		if (device_suspend(PM_SUSPEND_MEM)) {
+			prepare_status(1, 0, "Suspending devices failed. Using normal powerdown.");
+			suspend_power_down_finish();
+			goto abort_ACPI_sleep;
+		}
+		if (suspend_enter_acpi_state(PM_SUSPEND_MEM)) {
+			prepare_status(1, 0, "Entering ACPI state failed. Using normal powerdown.");
+			suspend_power_down_finish();
+			goto abort_ACPI_sleep;
+		}
+		suspend_power_down_finish();
+		return;
 	} else
 		prepare_status(1, 0, "Powering down.");
 	
+abort_ACPI_sleep:
 	/* 
 	 * FIXME: At resume, we'll still think we used S4 if we tried it.
 	 * Does it matter?
 	 */
 	suspend_acpi_state_used = 0;
+	device_shutdown();
 	suspend_power_off();
 }
 
+void suspend_drivers_resume(int stage)
+{
+	switch (stage) {
+		case SUSPEND_DRIVERS_IRQS_DISABLED:
+			BUG_ON(!irqs_disabled());
+			device_power_up();
+			break;
+
+		case SUSPEND_DRIVERS_IRQS_ENABLED:
+			BUG_ON(irqs_disabled());
+#ifdef CONFIG_ACPI
+			if (suspend_acpi_state_used)
+				acpi_leave_sleep_state(suspend_acpi_state_used);
+#endif
+			device_resume();
+			suspend_power_down_finish();
+			break;
+	}
+}
+
+/*	suspend_drivers_suspend
+ *	@stage - one of:
+ *		1: Power down drivers not used in writing the image
+ *		2: Quiesce drivers used in writing the image
+ *		   (prior to making atomic copy)
+ *		3: Power down drivers used in writing the image and
+ *		   enter the suspend mode if configured to do so.
+ *
+ */
+int suspend_drivers_suspend(int stage)
+{
+	int result = 0;
+	const int state = PM_SUSPEND_DISK;
+
+	switch (stage) {
+		case SUSPEND_DRIVERS_IRQS_DISABLED:
+			BUG_ON(!irqs_disabled());
+			result = device_power_down(state);
+			break;
+
+		case SUSPEND_DRIVERS_IRQS_ENABLED:
+			BUG_ON(irqs_disabled());
+			result = device_suspend(state);
+			break;
+	}
+	return result;
+}
+
