14 files changed, 134 insertions, 205 deletions

diff --git a/drivers/base/attribute_container.c b/drivers/base/attribute_container.c
index 1ec0654665cf..7370d7cf5988 100644
--- a/drivers/base/attribute_container.c
+++ b/drivers/base/attribute_container.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 
 #include "base.h"
 
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 5512d84452f2..47eb02d9f1af 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -44,6 +44,6 @@ struct class_device_attribute *to_class_dev_attr(struct attribute *_attr)
 
 extern char *make_class_name(const char *name, struct kobject *kobj);
 
-extern void devres_release_all(struct device *dev);
+extern int devres_release_all(struct device *dev);
 
 extern struct kset devices_subsys;
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index dca734819e50..61c67526a656 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -138,12 +138,24 @@ void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
         }
 }
 
-static struct kobj_type ktype_bus = {
+static struct kobj_type bus_ktype = {
         .sysfs_ops      = &bus_sysfs_ops,
+};
+
+static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
+{
+        struct kobj_type *ktype = get_ktype(kobj);
 
+        if (ktype == &bus_ktype)
+                return 1;
+        return 0;
+}
+
+static struct kset_uevent_ops bus_uevent_ops = {
+        .filter = bus_uevent_filter,
 };
 
-static decl_subsys(bus, &ktype_bus, NULL);
+static decl_subsys(bus, &bus_ktype, &bus_uevent_ops);
 
 
 #ifdef CONFIG_HOTPLUG
@@ -562,7 +574,6 @@ static int add_probe_files(struct bus_type *bus)
 
         bus->drivers_probe_attr.attr.name = "drivers_probe";
         bus->drivers_probe_attr.attr.mode = S_IWUSR;
-        bus->drivers_probe_attr.attr.owner = bus->owner;
         bus->drivers_probe_attr.store = store_drivers_probe;
         retval = bus_create_file(bus, &bus->drivers_probe_attr);
         if (retval)
@@ -570,7 +581,6 @@ static int add_probe_files(struct bus_type *bus)
 
         bus->drivers_autoprobe_attr.attr.name = "drivers_autoprobe";
         bus->drivers_autoprobe_attr.attr.mode = S_IWUSR | S_IRUGO;
-        bus->drivers_autoprobe_attr.attr.owner = bus->owner;
         bus->drivers_autoprobe_attr.show = show_drivers_autoprobe;
         bus->drivers_autoprobe_attr.store = store_drivers_autoprobe;
         retval = bus_create_file(bus, &bus->drivers_autoprobe_attr);
@@ -610,7 +620,8 @@ int bus_add_driver(struct device_driver *drv)
         if (error)
                 goto out_put_bus;
         drv->kobj.kset = &bus->drivers;
-        if ((error = kobject_register(&drv->kobj)))
+        error = kobject_register(&drv->kobj);
+        if (error)
                 goto out_put_bus;
 
         if (drv->bus->drivers_autoprobe) {
@@ -760,7 +771,8 @@ static int bus_add_attrs(struct bus_type * bus)
 
         if (bus->bus_attrs) {
                 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
-                        if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
+                        error = bus_create_file(bus,&bus->bus_attrs[i]);
+                        if (error)
                                 goto Err;
                 }
         }
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 8c506dbe3913..4d2222618b78 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -312,9 +312,6 @@ static void class_dev_release(struct kobject * kobj)
 
         pr_debug("device class '%s': release.\n", cd->class_id);
 
-        kfree(cd->devt_attr);
-        cd->devt_attr = NULL;
-
         if (cd->release)
                 cd->release(cd);
         else if (cls->release)
@@ -547,6 +544,9 @@ static ssize_t show_dev(struct class_device *class_dev, char *buf)
         return print_dev_t(buf, class_dev->devt);
 }
 
+static struct class_device_attribute class_devt_attr =
+        __ATTR(dev, S_IRUGO, show_dev, NULL);
+
 static ssize_t store_uevent(struct class_device *class_dev,
                             const char *buf, size_t count)
 {
@@ -554,6 +554,9 @@ static ssize_t store_uevent(struct class_device *class_dev,
         return count;
 }
 
+static struct class_device_attribute class_uevent_attr =
+        __ATTR(uevent, S_IWUSR, NULL, store_uevent);
+
 void class_device_initialize(struct class_device *class_dev)
 {
         kobj_set_kset_s(class_dev, class_obj_subsys);
@@ -603,32 +606,15 @@ int class_device_add(struct class_device *class_dev)
                                   &parent_class->subsys.kobj, "subsystem");
         if (error)
                 goto out3;
-        class_dev->uevent_attr.attr.name = "uevent";
-        class_dev->uevent_attr.attr.mode = S_IWUSR;
-        class_dev->uevent_attr.attr.owner = parent_class->owner;
-        class_dev->uevent_attr.store = store_uevent;
-        error = class_device_create_file(class_dev, &class_dev->uevent_attr);
+
+        error = class_device_create_file(class_dev, &class_uevent_attr);
         if (error)
                 goto out3;
 
         if (MAJOR(class_dev->devt)) {
-                struct class_device_attribute *attr;
-                attr = kzalloc(sizeof(*attr), GFP_KERNEL);
-                if (!attr) {
-                        error = -ENOMEM;
-                        goto out4;
-                }
-                attr->attr.name = "dev";
-                attr->attr.mode = S_IRUGO;
-                attr->attr.owner = parent_class->owner;
-                attr->show = show_dev;
-                error = class_device_create_file(class_dev, attr);
-                if (error) {
-                        kfree(attr);
+                error = class_device_create_file(class_dev, &class_devt_attr);
+                if (error)
                         goto out4;
-                }
-
-                class_dev->devt_attr = attr;
         }
 
         error = class_device_add_attrs(class_dev);
@@ -671,10 +657,10 @@ int class_device_add(struct class_device *class_dev)
  out6:
         class_device_remove_attrs(class_dev);
  out5:
-        if (class_dev->devt_attr)
-                class_device_remove_file(class_dev, class_dev->devt_attr);
+        if (MAJOR(class_dev->devt))
+                class_device_remove_file(class_dev, &class_devt_attr);
  out4:
-        class_device_remove_file(class_dev, &class_dev->uevent_attr);
+        class_device_remove_file(class_dev, &class_uevent_attr);
  out3:
         kobject_del(&class_dev->kobj);
  out2:
@@ -774,9 +760,9 @@ void class_device_del(struct class_device *class_dev)
                 sysfs_remove_link(&class_dev->kobj, "device");
         }
         sysfs_remove_link(&class_dev->kobj, "subsystem");
-        class_device_remove_file(class_dev, &class_dev->uevent_attr);
-        if (class_dev->devt_attr)
-                class_device_remove_file(class_dev, class_dev->devt_attr);
+        class_device_remove_file(class_dev, &class_uevent_attr);
+        if (MAJOR(class_dev->devt))
+                class_device_remove_file(class_dev, &class_devt_attr);
         class_device_remove_attrs(class_dev);
         class_device_remove_groups(class_dev);
 
diff --git a/drivers/base/core.c b/drivers/base/core.c
index dd40d78a023d..0455aa78fa13 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -310,6 +310,9 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
+static struct device_attribute uevent_attr =
+        __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
+
 static int device_add_attributes(struct device *dev,
                                  struct device_attribute *attrs)
 {
@@ -423,6 +426,9 @@ static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
         return print_dev_t(buf, dev->devt);
 }
 
+static struct device_attribute devt_attr =
+        __ATTR(dev, S_IRUGO, show_dev, NULL);
+
 /*
  *      devices_subsys - structure to be registered with kobject core.
  */
@@ -681,35 +687,14 @@ int device_add(struct device *dev)
                 blocking_notifier_call_chain(&dev->bus->bus_notifier,
                                              BUS_NOTIFY_ADD_DEVICE, dev);
 
-        dev->uevent_attr.attr.name = "uevent";
-        dev->uevent_attr.attr.mode = S_IRUGO | S_IWUSR;
-        if (dev->driver)
-                dev->uevent_attr.attr.owner = dev->driver->owner;
-        dev->uevent_attr.store = store_uevent;
-        dev->uevent_attr.show = show_uevent;
-        error = device_create_file(dev, &dev->uevent_attr);
+        error = device_create_file(dev, &uevent_attr);
         if (error)
                 goto attrError;
 
         if (MAJOR(dev->devt)) {
-                struct device_attribute *attr;
-                attr = kzalloc(sizeof(*attr), GFP_KERNEL);
-                if (!attr) {
-                        error = -ENOMEM;
-                        goto ueventattrError;
-                }
-                attr->attr.name = "dev";
-                attr->attr.mode = S_IRUGO;
-                if (dev->driver)
-                        attr->attr.owner = dev->driver->owner;
-                attr->show = show_dev;
-                error = device_create_file(dev, attr);
-                if (error) {
-                        kfree(attr);
+                error = device_create_file(dev, &devt_attr);
+                if (error)
                         goto ueventattrError;
-                }
-
-                dev->devt_attr = attr;
         }
 
         if (dev->class) {
@@ -733,11 +718,14 @@ int device_add(struct device *dev)
                 }
         }
 
-        if ((error = device_add_attrs(dev)))
+        error = device_add_attrs(dev);
+        if (error)
                 goto AttrsError;
-        if ((error = device_pm_add(dev)))
+        error = device_pm_add(dev);
+        if (error)
                 goto PMError;
-        if ((error = bus_add_device(dev)))
+        error = bus_add_device(dev);
+        if (error)
                 goto BusError;
         kobject_uevent(&dev->kobj, KOBJ_ADD);
         bus_attach_device(dev);
@@ -767,10 +755,8 @@ int device_add(struct device *dev)
                                              BUS_NOTIFY_DEL_DEVICE, dev);
         device_remove_attrs(dev);
  AttrsError:
-        if (dev->devt_attr) {
-                device_remove_file(dev, dev->devt_attr);
-                kfree(dev->devt_attr);
-        }
+        if (MAJOR(dev->devt))
+                device_remove_file(dev, &devt_attr);
 
         if (dev->class) {
                 sysfs_remove_link(&dev->kobj, "subsystem");
@@ -792,7 +778,7 @@ int device_add(struct device *dev)
                 }
         }
  ueventattrError:
-        device_remove_file(dev, &dev->uevent_attr);
+        device_remove_file(dev, &uevent_attr);
  attrError:
         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
         kobject_del(&dev->kobj);
@@ -869,10 +855,8 @@ void device_del(struct device * dev)
 
         if (parent)
                 klist_del(&dev->knode_parent);
-        if (dev->devt_attr) {
-                device_remove_file(dev, dev->devt_attr);
-                kfree(dev->devt_attr);
-        }
+        if (MAJOR(dev->devt))
+                device_remove_file(dev, &devt_attr);
         if (dev->class) {
                 sysfs_remove_link(&dev->kobj, "subsystem");
                 /* If this is not a "fake" compatible device, remove the
@@ -926,7 +910,7 @@ void device_del(struct device * dev)
                         up(&dev->class->sem);
                 }
         }
-        device_remove_file(dev, &dev->uevent_attr);
+        device_remove_file(dev, &uevent_attr);
         device_remove_attrs(dev);
         bus_remove_device(dev);
 
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index b0088b0efecd..7ac474db88c5 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -281,24 +281,16 @@ int driver_attach(struct device_driver * drv)
         return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
 }
 
-/**
- *      device_release_driver - manually detach device from driver.
- *      @dev:   device.
- *
- *      Manually detach device from driver.
- *
+/*
  *      __device_release_driver() must be called with @dev->sem held.
- *      When called for a USB interface, @dev->parent->sem must be held
- *      as well.
+ *      When called for a USB interface, @dev->parent->sem must be held as well.
  */
-
 static void __device_release_driver(struct device * dev)
 {
         struct device_driver * drv;
 
-        drv = dev->driver;
+        drv = get_driver(dev->driver);
         if (drv) {
-                get_driver(drv);
                 driver_sysfs_remove(dev);
                 sysfs_remove_link(&dev->kobj, "driver");
                 klist_remove(&dev->knode_driver);
@@ -318,6 +310,13 @@ static void __device_release_driver(struct device * dev)
         }
 }
 
+/**
+ *      device_release_driver - manually detach device from driver.
+ *      @dev:   device.
+ *
+ *      Manually detach device from driver.
+ *      When called for a USB interface, @dev->parent->sem must be held.
+ */
 void device_release_driver(struct device * dev)
 {
         /*
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index e1c0730a3b99..e8beb8e5b626 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -10,6 +10,8 @@
 #include <linux/device.h>
 #include <linux/module.h>
 
+#include "base.h"
+
 struct devres_node {
         struct list_head                entry;
         dr_release_t                    release;
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 89a5f4a54913..53f0ee6f3016 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -175,7 +175,7 @@ static ssize_t firmware_loading_store(struct device *dev,
 static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
 
 static ssize_t
-firmware_data_read(struct kobject *kobj,
+firmware_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
                    char *buffer, loff_t offset, size_t count)
 {
         struct device *dev = to_dev(kobj);
@@ -240,7 +240,7 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
  *      the driver as a firmware image.
  **/
 static ssize_t
-firmware_data_write(struct kobject *kobj,
+firmware_data_write(struct kobject *kobj, struct bin_attribute *bin_attr,
                     char *buffer, loff_t offset, size_t count)
 {
         struct device *dev = to_dev(kobj);
@@ -271,7 +271,7 @@ out:
 }
 
 static struct bin_attribute firmware_attr_data_tmpl = {
-        .attr = {.name = "data", .mode = 0644, .owner = THIS_MODULE},
+        .attr = {.name = "data", .mode = 0644},
         .size = 0,
         .read = firmware_data_read,
         .write = firmware_data_write,
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 05dc8764e765..eb9f38d0aa58 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -20,64 +20,44 @@
  */
 
 #include <linux/device.h>
+#include <linux/mutex.h>
+
 #include "power.h"
 
 LIST_HEAD(dpm_active);
 LIST_HEAD(dpm_off);
 LIST_HEAD(dpm_off_irq);
 
-DECLARE_MUTEX(dpm_sem);
-DECLARE_MUTEX(dpm_list_sem);
+DEFINE_MUTEX(dpm_mtx);
+DEFINE_MUTEX(dpm_list_mtx);
 
 int (*platform_enable_wakeup)(struct device *dev, int is_on);
 
-
-/**
- *      device_pm_set_parent - Specify power dependency.
- *      @dev:           Device who needs power.
- *      @parent:        Device that supplies power.
- *
- *      This function is used to manually describe a power-dependency
- *      relationship. It may be used to specify a transversal relationship
- *      (where the power supplier is not the physical (or electrical)
- *      ancestor of a specific device.
- *      The effect of this is that the supplier will not be powered down
- *      before the power dependent.
- */
-
-void device_pm_set_parent(struct device * dev, struct device * parent)
-{
-        put_device(dev->power.pm_parent);
-        dev->power.pm_parent = get_device(parent);
-}
-EXPORT_SYMBOL_GPL(device_pm_set_parent);
-
-int device_pm_add(struct device * dev)
+int device_pm_add(struct device *dev)
 {
         int error;
 
         pr_debug("PM: Adding info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus",
                  kobject_name(&dev->kobj));
-        down(&dpm_list_sem);
+        mutex_lock(&dpm_list_mtx);
         list_add_tail(&dev->power.entry, &dpm_active);
-        device_pm_set_parent(dev, dev->parent);
-        if ((error = dpm_sysfs_add(dev)))
+        error = dpm_sysfs_add(dev);
+        if (error)
                 list_del(&dev->power.entry);
-        up(&dpm_list_sem);
+        mutex_unlock(&dpm_list_mtx);
         return error;
 }
 
-void device_pm_remove(struct device * dev)
+void device_pm_remove(struct device *dev)
 {
         pr_debug("PM: Removing info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus",
                  kobject_name(&dev->kobj));
-        down(&dpm_list_sem);
+        mutex_lock(&dpm_list_mtx);
         dpm_sysfs_remove(dev);
-        put_device(dev->power.pm_parent);
         list_del_init(&dev->power.entry);
-        up(&dpm_list_sem);
+        mutex_unlock(&dpm_list_mtx);
 }
 
 
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index fb3d35a9e101..2760f25b3ac5 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -14,12 +14,12 @@ extern void device_shutdown(void);
 /*
  * Used to synchronize global power management operations.
  */
-extern struct semaphore dpm_sem;
+extern struct mutex dpm_mtx;
 
 /*
  * Used to serialize changes to the dpm_* lists.
  */
-extern struct semaphore dpm_list_sem;
+extern struct mutex dpm_list_mtx;
 
 /*
  * The PM lists.
diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
index a2c64188d713..00fd84ae6e66 100644
--- a/drivers/base/power/resume.c
+++ b/drivers/base/power/resume.c
@@ -29,14 +29,6 @@ int resume_device(struct device * dev)
 
         down(&dev->sem);
 
-        if (dev->power.pm_parent
-                        && dev->power.pm_parent->power.power_state.event) {
-                dev_err(dev, "PM: resume from %d, parent %s still %d\n",
-                        dev->power.power_state.event,
-                        dev->power.pm_parent->bus_id,
-                        dev->power.pm_parent->power.power_state.event);
-        }
-
         if (dev->bus && dev->bus->resume) {
                 dev_dbg(dev,"resuming\n");
                 error = dev->bus->resume(dev);
@@ -80,7 +72,7 @@ static int resume_device_early(struct device * dev)
  */
 void dpm_resume(void)
 {
-        down(&dpm_list_sem);
+        mutex_lock(&dpm_list_mtx);
         while(!list_empty(&dpm_off)) {
                 struct list_head * entry = dpm_off.next;
                 struct device * dev = to_device(entry);
@@ -88,13 +80,12 @@ void dpm_resume(void)
                 get_device(dev);
                 list_move_tail(entry, &dpm_active);
 
-                up(&dpm_list_sem);
-                if (!dev->power.prev_state.event)
-                        resume_device(dev);
-                down(&dpm_list_sem);
+                mutex_unlock(&dpm_list_mtx);
+                resume_device(dev);
+                mutex_lock(&dpm_list_mtx);
                 put_device(dev);
         }
-        up(&dpm_list_sem);
+        mutex_unlock(&dpm_list_mtx);
 }
 
 
@@ -108,9 +99,9 @@ void dpm_resume(void)
 void device_resume(void)
 {
         might_sleep();
-        down(&dpm_sem);
+        mutex_lock(&dpm_mtx);
         dpm_resume();
-        up(&dpm_sem);
+        mutex_unlock(&dpm_mtx);
 }
 
 EXPORT_SYMBOL_GPL(device_resume);
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 96370ec1d673..df6174d85866 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -32,9 +32,9 @@ static void runtime_resume(struct device * dev)
 
 void dpm_runtime_resume(struct device * dev)
 {
-        down(&dpm_sem);
+        mutex_lock(&dpm_mtx);
         runtime_resume(dev);
-        up(&dpm_sem);
+        mutex_unlock(&dpm_mtx);
 }
 EXPORT_SYMBOL(dpm_runtime_resume);
 
@@ -49,7 +49,7 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state)
 {
         int error = 0;
 
-        down(&dpm_sem);
+        mutex_lock(&dpm_mtx);
         if (dev->power.power_state.event == state.event)
                 goto Done;
 
@@ -59,7 +59,7 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state)
         if (!(error = suspend_device(dev, state)))
                 dev->power.power_state = state;
  Done:
-        up(&dpm_sem);
+        mutex_unlock(&dpm_mtx);
         return error;
 }
 EXPORT_SYMBOL(dpm_runtime_suspend);
@@ -78,8 +78,8 @@ EXPORT_SYMBOL(dpm_runtime_suspend);
  */
 void dpm_set_power_state(struct device * dev, pm_message_t state)
 {
-        down(&dpm_sem);
+        mutex_lock(&dpm_mtx);
         dev->power.power_state = state;
-        up(&dpm_sem);
+        mutex_unlock(&dpm_mtx);
 }
 #endif  /*  0  */
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
index 42d2b86ba765..26df9b231737 100644
--- a/drivers/base/power/suspend.c
+++ b/drivers/base/power/suspend.c
@@ -40,6 +40,14 @@ static inline char *suspend_verb(u32 event)
 }
 
 
+static void
+suspend_device_dbg(struct device *dev, pm_message_t state, char *info)
+{
+        dev_dbg(dev, "%s%s%s\n", info, suspend_verb(state.event),
+                ((state.event == PM_EVENT_SUSPEND) && device_may_wakeup(dev)) ?
+                ", may wakeup" : "");
+}
+
 /**
  *      suspend_device - Save state of one device.
  *      @dev:   Device.
@@ -55,49 +63,21 @@ int suspend_device(struct device * dev, pm_message_t state)
                 dev_dbg(dev, "PM: suspend %d-->%d\n",
                         dev->power.power_state.event, state.event);
         }
-        if (dev->power.pm_parent
-                        && dev->power.pm_parent->power.power_state.event) {
-                dev_err(dev,
-                        "PM: suspend %d->%d, parent %s already %d\n",
-                        dev->power.power_state.event, state.event,
-                        dev->power.pm_parent->bus_id,
-                        dev->power.pm_parent->power.power_state.event);
-        }
-
-        dev->power.prev_state = dev->power.power_state;
 
-        if (dev->class && dev->class->suspend && !dev->power.power_state.event) {
-                dev_dbg(dev, "class %s%s\n",
-                        suspend_verb(state.event),
-                        ((state.event == PM_EVENT_SUSPEND)
-                                        && device_may_wakeup(dev))
-                                ? ", may wakeup"
-                                : ""
-                        );
+        if (dev->class && dev->class->suspend) {
+                suspend_device_dbg(dev, state, "class ");
                 error = dev->class->suspend(dev, state);
                 suspend_report_result(dev->class->suspend, error);
         }
 
-        if (!error && dev->type && dev->type->suspend && !dev->power.power_state.event) {
-                dev_dbg(dev, "%s%s\n",
-                        suspend_verb(state.event),
-                        ((state.event == PM_EVENT_SUSPEND)
-                                        && device_may_wakeup(dev))
-                                ? ", may wakeup"
-                                : ""
-                        );
+        if (!error && dev->type && dev->type->suspend) {
+                suspend_device_dbg(dev, state, "type ");
                 error = dev->type->suspend(dev, state);
                 suspend_report_result(dev->type->suspend, error);
         }
 
-        if (!error && dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
-                dev_dbg(dev, "%s%s\n",
-                        suspend_verb(state.event),
-                        ((state.event == PM_EVENT_SUSPEND)
-                                        && device_may_wakeup(dev))
-                                ? ", may wakeup"
-                                : ""
-                        );
+        if (!error && dev->bus && dev->bus->suspend) {
+                suspend_device_dbg(dev, state, "");
                 error = dev->bus->suspend(dev, state);
                 suspend_report_result(dev->bus->suspend, error);
         }
@@ -108,21 +88,15 @@ int suspend_device(struct device * dev, pm_message_t state)
 
 /*
  * This is called with interrupts off, only a single CPU
- * running. We can't do down() on a semaphore (and we don't
+ * running. We can't acquire a mutex or semaphore (and we don't
  * need the protection)
  */
 static int suspend_device_late(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
-        if (dev->bus && dev->bus->suspend_late && !dev->power.power_state.event) {
-                dev_dbg(dev, "LATE %s%s\n",
-                        suspend_verb(state.event),
-                        ((state.event == PM_EVENT_SUSPEND)
-                                        && device_may_wakeup(dev))
-                                ? ", may wakeup"
-                                : ""
-                        );
+        if (dev->bus && dev->bus->suspend_late) {
+                suspend_device_dbg(dev, state, "LATE ");
                 error = dev->bus->suspend_late(dev, state);
                 suspend_report_result(dev->bus->suspend_late, error);
         }
@@ -153,18 +127,18 @@ int device_suspend(pm_message_t state)
         int error = 0;
 
         might_sleep();
-        down(&dpm_sem);
-        down(&dpm_list_sem);
+        mutex_lock(&dpm_mtx);
+        mutex_lock(&dpm_list_mtx);
         while (!list_empty(&dpm_active) && error == 0) {
                 struct list_head * entry = dpm_active.prev;
                 struct device * dev = to_device(entry);
 
                 get_device(dev);
-                up(&dpm_list_sem);
+                mutex_unlock(&dpm_list_mtx);
 
                 error = suspend_device(dev, state);
 
-                down(&dpm_list_sem);
+                mutex_lock(&dpm_list_mtx);
 
                 /* Check if the device got removed */
                 if (!list_empty(&dev->power.entry)) {
@@ -179,11 +153,11 @@ int device_suspend(pm_message_t state)
                                 error == -EAGAIN ? " (please convert to suspend_late)" : "");
                 put_device(dev);
         }
-        up(&dpm_list_sem);
+        mutex_unlock(&dpm_list_mtx);
         if (error)
                 dpm_resume();
 
-        up(&dpm_sem);
+        mutex_unlock(&dpm_mtx);
         return error;
 }
 
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 29f1291966c1..18febe26caa1 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -21,7 +21,7 @@
 #include <linux/string.h>
 #include <linux/pm.h>
 #include <linux/device.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "base.h"
 
@@ -155,7 +155,7 @@ EXPORT_SYMBOL_GPL(sysdev_class_unregister);
 
 
 static LIST_HEAD(sysdev_drivers);
-static DECLARE_MUTEX(sysdev_drivers_lock);
+static DEFINE_MUTEX(sysdev_drivers_lock);
 
 /**
  *      sysdev_driver_register - Register auxillary driver
@@ -172,7 +172,7 @@ static DECLARE_MUTEX(sysdev_drivers_lock);
 int sysdev_driver_register(struct sysdev_class * cls,
                            struct sysdev_driver * drv)
 {
-        down(&sysdev_drivers_lock);
+        mutex_lock(&sysdev_drivers_lock);
         if (cls && kset_get(&cls->kset)) {
                 list_add_tail(&drv->entry, &cls->drivers);
 
@@ -184,7 +184,7 @@ int sysdev_driver_register(struct sysdev_class * cls,
                 }
         } else
                 list_add_tail(&drv->entry, &sysdev_drivers);
-        up(&sysdev_drivers_lock);
+        mutex_unlock(&sysdev_drivers_lock);
         return 0;
 }
 
@@ -197,7 +197,7 @@ int sysdev_driver_register(struct sysdev_class * cls,
 void sysdev_driver_unregister(struct sysdev_class * cls,
                               struct sysdev_driver * drv)
 {
-        down(&sysdev_drivers_lock);
+        mutex_lock(&sysdev_drivers_lock);
         list_del_init(&drv->entry);
         if (cls) {
                 if (drv->remove) {
@@ -207,7 +207,7 @@ void sysdev_driver_unregister(struct sysdev_class * cls,
                 }
                 kset_put(&cls->kset);
         }
-        up(&sysdev_drivers_lock);
+        mutex_unlock(&sysdev_drivers_lock);
 }
 
 EXPORT_SYMBOL_GPL(sysdev_driver_register);
@@ -246,7 +246,7 @@ int sysdev_register(struct sys_device * sysdev)
         if (!error) {
                 struct sysdev_driver * drv;
 
-                down(&sysdev_drivers_lock);
+                mutex_lock(&sysdev_drivers_lock);
                 /* Generic notification is implicit, because it's that
                  * code that should have called us.
                  */
@@ -262,7 +262,7 @@ int sysdev_register(struct sys_device * sysdev)
                         if (drv->add)
                                 drv->add(sysdev);
                 }
-                up(&sysdev_drivers_lock);
+                mutex_unlock(&sysdev_drivers_lock);
         }
         return error;
 }
@@ -271,7 +271,7 @@ void sysdev_unregister(struct sys_device * sysdev)
 {
         struct sysdev_driver * drv;
 
-        down(&sysdev_drivers_lock);
+        mutex_lock(&sysdev_drivers_lock);
         list_for_each_entry(drv, &sysdev_drivers, entry) {
                 if (drv->remove)
                         drv->remove(sysdev);
@@ -281,7 +281,7 @@ void sysdev_unregister(struct sys_device * sysdev)
                 if (drv->remove)
                         drv->remove(sysdev);
         }
-        up(&sysdev_drivers_lock);
+        mutex_unlock(&sysdev_drivers_lock);
 
         kobject_unregister(&sysdev->kobj);
 }
@@ -308,7 +308,7 @@ void sysdev_shutdown(void)
 
         pr_debug("Shutting Down System Devices\n");
 
-        down(&sysdev_drivers_lock);
+        mutex_lock(&sysdev_drivers_lock);
         list_for_each_entry_reverse(cls, &system_subsys.list,
                                     kset.kobj.entry) {
                 struct sys_device * sysdev;
@@ -337,7 +337,7 @@ void sysdev_shutdown(void)
                                 cls->shutdown(sysdev);
                 }
         }
-        up(&sysdev_drivers_lock);
+        mutex_unlock(&sysdev_drivers_lock);
 }
 
 static void __sysdev_resume(struct sys_device *dev)