Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

14 files changed, 503 insertions, 650 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 5d6312e33490..d7da109c24fd 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -1,5 +1,13 @@
 menu "Generic Driver Options"
 
+config UEVENT_HELPER_PATH
+        string "path to uevent helper"
+        depends on HOTPLUG
+        default "/sbin/hotplug"
+        help
+          Path to uevent helper program forked by the kernel for
+          every uevent.
+
 config STANDALONE
         bool "Select only drivers that don't need compile-time external firmware" if EXPERIMENTAL
         default y
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 47eb02d9f1af..10b2fb6c9ce6 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -18,8 +18,6 @@ extern int attribute_container_init(void);
 extern int bus_add_device(struct device * dev);
 extern void bus_attach_device(struct device * dev);
 extern void bus_remove_device(struct device * dev);
-extern struct bus_type *get_bus(struct bus_type * bus);
-extern void put_bus(struct bus_type * bus);
 
 extern int bus_add_driver(struct device_driver *);
 extern void bus_remove_driver(struct device_driver *);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 61c67526a656..9a19b071c573 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -30,6 +30,17 @@
 static int __must_check bus_rescan_devices_helper(struct device *dev,
                                                 void *data);
 
+static struct bus_type *bus_get(struct bus_type *bus)
+{
+        return bus ? container_of(kset_get(&bus->subsys),
+                                struct bus_type, subsys) : NULL;
+}
+
+static void bus_put(struct bus_type *bus)
+{
+        kset_put(&bus->subsys);
+}
+
 static ssize_t
 drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 {
@@ -78,7 +89,7 @@ static void driver_release(struct kobject * kobj)
          */
 }
 
-static struct kobj_type ktype_driver = {
+static struct kobj_type driver_ktype = {
         .sysfs_ops      = &driver_sysfs_ops,
         .release        = driver_release,
 };
@@ -122,9 +133,9 @@ static struct sysfs_ops bus_sysfs_ops = {
 int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
 {
         int error;
-        if (get_bus(bus)) {
+        if (bus_get(bus)) {
                 error = sysfs_create_file(&bus->subsys.kobj, &attr->attr);
-                put_bus(bus);
+                bus_put(bus);
         } else
                 error = -EINVAL;
         return error;
@@ -132,9 +143,9 @@ int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
 
 void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
 {
-        if (get_bus(bus)) {
+        if (bus_get(bus)) {
                 sysfs_remove_file(&bus->subsys.kobj, &attr->attr);
-                put_bus(bus);
+                bus_put(bus);
         }
 }
 
@@ -172,7 +183,7 @@ static int driver_helper(struct device *dev, void *data)
 static ssize_t driver_unbind(struct device_driver *drv,
                              const char *buf, size_t count)
 {
-        struct bus_type *bus = get_bus(drv->bus);
+        struct bus_type *bus = bus_get(drv->bus);
         struct device *dev;
         int err = -ENODEV;
 
@@ -186,7 +197,7 @@ static ssize_t driver_unbind(struct device_driver *drv,
                 err = count;
         }
         put_device(dev);
-        put_bus(bus);
+        bus_put(bus);
         return err;
 }
 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
@@ -199,7 +210,7 @@ static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
 static ssize_t driver_bind(struct device_driver *drv,
                            const char *buf, size_t count)
 {
-        struct bus_type *bus = get_bus(drv->bus);
+        struct bus_type *bus = bus_get(drv->bus);
         struct device *dev;
         int err = -ENODEV;
 
@@ -219,7 +230,7 @@ static ssize_t driver_bind(struct device_driver *drv,
                         err = -ENODEV;
         }
         put_device(dev);
-        put_bus(bus);
+        bus_put(bus);
         return err;
 }
 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
@@ -430,7 +441,7 @@ static inline void remove_deprecated_bus_links(struct device *dev) { }
  */
 int bus_add_device(struct device * dev)
 {
-        struct bus_type * bus = get_bus(dev->bus);
+        struct bus_type * bus = bus_get(dev->bus);
         int error = 0;
 
         if (bus) {
@@ -459,7 +470,7 @@ out_subsys:
 out_id:
         device_remove_attrs(bus, dev);
 out_put:
-        put_bus(dev->bus);
+        bus_put(dev->bus);
         return error;
 }
 
@@ -509,7 +520,7 @@ void bus_remove_device(struct device * dev)
                 }
                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
                 device_release_driver(dev);
-                put_bus(dev->bus);
+                bus_put(dev->bus);
         }
 }
 
@@ -568,32 +579,29 @@ static void remove_bind_files(struct device_driver *drv)
         driver_remove_file(drv, &driver_attr_unbind);
 }
 
+static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
+static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
+                show_drivers_autoprobe, store_drivers_autoprobe);
+
 static int add_probe_files(struct bus_type *bus)
 {
         int retval;
 
-        bus->drivers_probe_attr.attr.name = "drivers_probe";
-        bus->drivers_probe_attr.attr.mode = S_IWUSR;
-        bus->drivers_probe_attr.store = store_drivers_probe;
-        retval = bus_create_file(bus, &bus->drivers_probe_attr);
+        retval = bus_create_file(bus, &bus_attr_drivers_probe);
         if (retval)
                 goto out;
 
-        bus->drivers_autoprobe_attr.attr.name = "drivers_autoprobe";
-        bus->drivers_autoprobe_attr.attr.mode = S_IWUSR | S_IRUGO;
-        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);
+        retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
         if (retval)
-                bus_remove_file(bus, &bus->drivers_probe_attr);
+                bus_remove_file(bus, &bus_attr_drivers_probe);
 out:
         return retval;
 }
 
 static void remove_probe_files(struct bus_type *bus)
 {
-        bus_remove_file(bus, &bus->drivers_autoprobe_attr);
-        bus_remove_file(bus, &bus->drivers_probe_attr);
+        bus_remove_file(bus, &bus_attr_drivers_autoprobe);
+        bus_remove_file(bus, &bus_attr_drivers_probe);
 }
 #else
 static inline int add_bind_files(struct device_driver *drv) { return 0; }
@@ -602,6 +610,17 @@ static inline int add_probe_files(struct bus_type *bus) { return 0; }
 static inline void remove_probe_files(struct bus_type *bus) {}
 #endif
 
+static ssize_t driver_uevent_store(struct device_driver *drv,
+                                   const char *buf, size_t count)
+{
+        enum kobject_action action;
+
+        if (kobject_action_type(buf, count, &action) == 0)
+                kobject_uevent(&drv->kobj, action);
+        return count;
+}
+static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
+
 /**
  *      bus_add_driver - Add a driver to the bus.
  *      @drv:   driver.
@@ -609,7 +628,7 @@ static inline void remove_probe_files(struct bus_type *bus) {}
  */
 int bus_add_driver(struct device_driver *drv)
 {
-        struct bus_type * bus = get_bus(drv->bus);
+        struct bus_type * bus = bus_get(drv->bus);
         int error = 0;
 
         if (!bus)
@@ -632,6 +651,11 @@ int bus_add_driver(struct device_driver *drv)
         klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
         module_add_driver(drv->owner, drv);
 
+        error = driver_create_file(drv, &driver_attr_uevent);
+        if (error) {
+                printk(KERN_ERR "%s: uevent attr (%s) failed\n",
+                        __FUNCTION__, drv->name);
+        }
         error = driver_add_attrs(bus, drv);
         if (error) {
                 /* How the hell do we get out of this pickle? Give up */
@@ -649,7 +673,7 @@ int bus_add_driver(struct device_driver *drv)
 out_unregister:
         kobject_unregister(&drv->kobj);
 out_put_bus:
-        put_bus(bus);
+        bus_put(bus);
         return error;
 }
 
@@ -669,12 +693,13 @@ void bus_remove_driver(struct device_driver * drv)
 
         remove_bind_files(drv);
         driver_remove_attrs(drv->bus, drv);
+        driver_remove_file(drv, &driver_attr_uevent);
         klist_remove(&drv->knode_bus);
         pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
         driver_detach(drv);
         module_remove_driver(drv);
         kobject_unregister(&drv->kobj);
-        put_bus(drv->bus);
+        bus_put(drv->bus);
 }
 
 
@@ -729,18 +754,6 @@ int device_reprobe(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(device_reprobe);
 
-struct bus_type *get_bus(struct bus_type *bus)
-{
-        return bus ? container_of(subsys_get(&bus->subsys),
-                                struct bus_type, subsys) : NULL;
-}
-
-void put_bus(struct bus_type * bus)
-{
-        subsys_put(&bus->subsys);
-}
-
-
 /**
  *      find_bus - locate bus by name.
  *      @name:  name of bus.
@@ -808,6 +821,17 @@ static void klist_devices_put(struct klist_node *n)
         put_device(dev);
 }
 
+static ssize_t bus_uevent_store(struct bus_type *bus,
+                                const char *buf, size_t count)
+{
+        enum kobject_action action;
+
+        if (kobject_action_type(buf, count, &action) == 0)
+                kobject_uevent(&bus->subsys.kobj, action);
+        return count;
+}
+static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
+
 /**
  *      bus_register - register a bus with the system.
  *      @bus:   bus.
@@ -826,11 +850,16 @@ int bus_register(struct bus_type * bus)
         if (retval)
                 goto out;
 
-        subsys_set_kset(bus, bus_subsys);
+        bus->subsys.kobj.kset = &bus_subsys;
+
         retval = subsystem_register(&bus->subsys);
         if (retval)
                 goto out;
 
+        retval = bus_create_file(bus, &bus_attr_uevent);
+        if (retval)
+                goto bus_uevent_fail;
+
         kobject_set_name(&bus->devices.kobj, "devices");
         bus->devices.kobj.parent = &bus->subsys.kobj;
         retval = kset_register(&bus->devices);
@@ -839,7 +868,7 @@ int bus_register(struct bus_type * bus)
 
         kobject_set_name(&bus->drivers.kobj, "drivers");
         bus->drivers.kobj.parent = &bus->subsys.kobj;
-        bus->drivers.ktype = &ktype_driver;
+        bus->drivers.ktype = &driver_ktype;
         retval = kset_register(&bus->drivers);
         if (retval)
                 goto bus_drivers_fail;
@@ -866,6 +895,8 @@ bus_probe_files_fail:
 bus_drivers_fail:
         kset_unregister(&bus->devices);
 bus_devices_fail:
+        bus_remove_file(bus, &bus_attr_uevent);
+bus_uevent_fail:
         subsystem_unregister(&bus->subsys);
 out:
         return retval;
@@ -876,7 +907,7 @@ out:
  *      @bus:   bus.
  *
  *      Unregister the child subsystems and the bus itself.
- *      Finally, we call put_bus() to release the refcount
+ *      Finally, we call bus_put() to release the refcount
  */
 void bus_unregister(struct bus_type * bus)
 {
@@ -885,6 +916,7 @@ void bus_unregister(struct bus_type * bus)
         remove_probe_files(bus);
         kset_unregister(&bus->drivers);
         kset_unregister(&bus->devices);
+        bus_remove_file(bus, &bus_attr_uevent);
         subsystem_unregister(&bus->subsys);
 }
 
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 4d2222618b78..a863bb091e11 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -65,13 +65,13 @@ static struct sysfs_ops class_sysfs_ops = {
         .store  = class_attr_store,
 };
 
-static struct kobj_type ktype_class = {
+static struct kobj_type class_ktype = {
         .sysfs_ops      = &class_sysfs_ops,
         .release        = class_release,
 };
 
 /* Hotplug events for classes go to the class_obj subsys */
-static decl_subsys(class, &ktype_class, NULL);
+static decl_subsys(class, &class_ktype, NULL);
 
 
 int class_create_file(struct class * cls, const struct class_attribute * attr)
@@ -93,14 +93,14 @@ void class_remove_file(struct class * cls, const struct class_attribute * attr)
 static struct class *class_get(struct class *cls)
 {
         if (cls)
-                return container_of(subsys_get(&cls->subsys), struct class, subsys);
+                return container_of(kset_get(&cls->subsys), struct class, subsys);
         return NULL;
 }
 
 static void class_put(struct class * cls)
 {
         if (cls)
-                subsys_put(&cls->subsys);
+                kset_put(&cls->subsys);
 }
 
 
@@ -149,7 +149,7 @@ int class_register(struct class * cls)
         if (error)
                 return error;
 
-        subsys_set_kset(cls, class_subsys);
+        cls->subsys.kobj.kset = &class_subsys;
 
         error = subsystem_register(&cls->subsys);
         if (!error) {
@@ -180,8 +180,7 @@ static void class_device_create_release(struct class_device *class_dev)
 
 /* needed to allow these devices to have parent class devices */
 static int class_device_create_uevent(struct class_device *class_dev,
-                                       char **envp, int num_envp,
-                                       char *buffer, int buffer_size)
+                                      struct kobj_uevent_env *env)
 {
         pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
         return 0;
@@ -324,7 +323,7 @@ static void class_dev_release(struct kobject * kobj)
         }
 }
 
-static struct kobj_type ktype_class_device = {
+static struct kobj_type class_device_ktype = {
         .sysfs_ops      = &class_dev_sysfs_ops,
         .release        = class_dev_release,
 };
@@ -333,7 +332,7 @@ static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
-        if (ktype == &ktype_class_device) {
+        if (ktype == &class_device_ktype) {
                 struct class_device *class_dev = to_class_dev(kobj);
                 if (class_dev->class)
                         return 1;
@@ -403,64 +402,43 @@ static void remove_deprecated_class_device_links(struct class_device *cd)
 { }
 #endif
 
-static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                         int num_envp, char *buffer, int buffer_size)
+static int class_uevent(struct kset *kset, struct kobject *kobj,
+                        struct kobj_uevent_env *env)
 {
         struct class_device *class_dev = to_class_dev(kobj);
         struct device *dev = class_dev->dev;
-        int i = 0;
-        int length = 0;
         int retval = 0;
 
         pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
 
         if (MAJOR(class_dev->devt)) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MAJOR=%u", MAJOR(class_dev->devt));
+                add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
 
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MINOR=%u", MINOR(class_dev->devt));
+                add_uevent_var(env, "MINOR=%u", MINOR(class_dev->devt));
         }
 
         if (dev) {
                 const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
                 if (path) {
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVPATH=%s", path);
+                        add_uevent_var(env, "PHYSDEVPATH=%s", path);
                         kfree(path);
                 }
 
                 if (dev->bus)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVBUS=%s", dev->bus->name);
+                        add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
 
                 if (dev->driver)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVDRIVER=%s", dev->driver->name);
+                        add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
         }
 
-        /* terminate, set to next free slot, shrink available space */
-        envp[i] = NULL;
-        envp = &envp[i];
-        num_envp -= i;
-        buffer = &buffer[length];
-        buffer_size -= length;
-
         if (class_dev->uevent) {
                 /* have the class device specific function add its stuff */
-                retval = class_dev->uevent(class_dev, envp, num_envp,
-                                            buffer, buffer_size);
+                retval = class_dev->uevent(class_dev, env);
                 if (retval)
                         pr_debug("class_dev->uevent() returned %d\n", retval);
         } else if (class_dev->class->uevent) {
                 /* have the class specific function add its stuff */
-                retval = class_dev->class->uevent(class_dev, envp, num_envp,
-                                                   buffer, buffer_size);
+                retval = class_dev->class->uevent(class_dev, env);
                 if (retval)
                         pr_debug("class->uevent() returned %d\n", retval);
         }
@@ -474,7 +452,7 @@ static struct kset_uevent_ops class_uevent_ops = {
         .uevent =       class_uevent,
 };
 
-static decl_subsys(class_obj, &ktype_class_device, &class_uevent_ops);
+static decl_subsys(class_obj, &class_device_ktype, &class_uevent_ops);
 
 
 static int class_device_add_attrs(struct class_device * cd)
@@ -883,7 +861,7 @@ int __init classes_init(void)
 
         /* ick, this is ugly, the things we go through to keep from showing up
          * in sysfs... */
-        subsystem_init(&class_obj_subsys);
+        kset_init(&class_obj_subsys);
         if (!class_obj_subsys.kobj.parent)
                 class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
         return 0;
diff --git a/drivers/base/core.c b/drivers/base/core.c
index ec86d6fc2360..c1343414d285 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -108,7 +108,7 @@ static void device_release(struct kobject * kobj)
         }
 }
 
-static struct kobj_type ktype_device = {
+static struct kobj_type device_ktype = {
         .release        = device_release,
         .sysfs_ops      = &dev_sysfs_ops,
 };
@@ -118,7 +118,7 @@ static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
-        if (ktype == &ktype_device) {
+        if (ktype == &device_ktype) {
                 struct device *dev = to_dev(kobj);
                 if (dev->uevent_suppress)
                         return 0;
@@ -141,33 +141,23 @@ static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
         return NULL;
 }
 
-static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                        int num_envp, char *buffer, int buffer_size)
+static int dev_uevent(struct kset *kset, struct kobject *kobj,
+                      struct kobj_uevent_env *env)
 {
         struct device *dev = to_dev(kobj);
-        int i = 0;
-        int length = 0;
         int retval = 0;
 
         /* add the major/minor if present */
         if (MAJOR(dev->devt)) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MAJOR=%u", MAJOR(dev->devt));
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MINOR=%u", MINOR(dev->devt));
+                add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
+                add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
         }
 
         if (dev->type && dev->type->name)
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "DEVTYPE=%s", dev->type->name);
+                add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
 
         if (dev->driver)
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "DRIVER=%s", dev->driver->name);
+                add_uevent_var(env, "DRIVER=%s", dev->driver->name);
 
 #ifdef CONFIG_SYSFS_DEPRECATED
         if (dev->class) {
@@ -181,59 +171,43 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
 
                         path = kobject_get_path(&parent->kobj, GFP_KERNEL);
                         if (path) {
-                                add_uevent_var(envp, num_envp, &i,
-                                               buffer, buffer_size, &length,
-                                               "PHYSDEVPATH=%s", path);
+                                add_uevent_var(env, "PHYSDEVPATH=%s", path);
                                 kfree(path);
                         }
 
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVBUS=%s", parent->bus->name);
+                        add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);
 
                         if (parent->driver)
-                                add_uevent_var(envp, num_envp, &i,
-                                               buffer, buffer_size, &length,
-                                               "PHYSDEVDRIVER=%s", parent->driver->name);
+                                add_uevent_var(env, "PHYSDEVDRIVER=%s",
+                                               parent->driver->name);
                 }
         } else if (dev->bus) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "PHYSDEVBUS=%s", dev->bus->name);
+                add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
 
                 if (dev->driver)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVDRIVER=%s", dev->driver->name);
+                        add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
         }
 #endif
 
-        /* terminate, set to next free slot, shrink available space */
-        envp[i] = NULL;
-        envp = &envp[i];
-        num_envp -= i;
-        buffer = &buffer[length];
-        buffer_size -= length;
-
+        /* have the bus specific function add its stuff */
         if (dev->bus && dev->bus->uevent) {
-                /* have the bus specific function add its stuff */
-                retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->bus->uevent(dev, env);
                 if (retval)
                         pr_debug ("%s: bus uevent() returned %d\n",
                                   __FUNCTION__, retval);
         }
 
+        /* have the class specific function add its stuff */
         if (dev->class && dev->class->dev_uevent) {
-                /* have the class specific function add its stuff */
-                retval = dev->class->dev_uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->class->dev_uevent(dev, env);
                 if (retval)
                         pr_debug("%s: class uevent() returned %d\n",
                                  __FUNCTION__, retval);
         }
 
+        /* have the device type specific fuction add its stuff */
         if (dev->type && dev->type->uevent) {
-                /* have the device type specific fuction add its stuff */
-                retval = dev->type->uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->type->uevent(dev, env);
                 if (retval)
                         pr_debug("%s: dev_type uevent() returned %d\n",
                                  __FUNCTION__, retval);
@@ -253,22 +227,18 @@ static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
 {
         struct kobject *top_kobj;
         struct kset *kset;
-        char *envp[32];
-        char *data = NULL;
-        char *pos;
+        struct kobj_uevent_env *env = NULL;
         int i;
         size_t count = 0;
         int retval;
 
         /* search the kset, the device belongs to */
         top_kobj = &dev->kobj;
-        if (!top_kobj->kset && top_kobj->parent) {
-                do {
-                        top_kobj = top_kobj->parent;
-                } while (!top_kobj->kset && top_kobj->parent);
-        }
+        while (!top_kobj->kset && top_kobj->parent)
+                top_kobj = top_kobj->parent;
         if (!top_kobj->kset)
                 goto out;
+
         kset = top_kobj->kset;
         if (!kset->uevent_ops || !kset->uevent_ops->uevent)
                 goto out;
@@ -278,43 +248,29 @@ static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
                 if (!kset->uevent_ops->filter(kset, &dev->kobj))
                         goto out;
 
-        data = (char *)get_zeroed_page(GFP_KERNEL);
-        if (!data)
+        env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
+        if (!env)
                 return -ENOMEM;
 
         /* let the kset specific function add its keys */
-        pos = data;
-        memset(envp, 0, sizeof(envp));
-        retval = kset->uevent_ops->uevent(kset, &dev->kobj,
-                                          envp, ARRAY_SIZE(envp),
-                                          pos, PAGE_SIZE);
+        retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
         if (retval)
                 goto out;
 
         /* copy keys to file */
-        for (i = 0; envp[i]; i++) {
-                pos = &buf[count];
-                count += sprintf(pos, "%s\n", envp[i]);
-        }
+        for (i = 0; i < env->envp_idx; i++)
+                count += sprintf(&buf[count], "%s\n", env->envp[i]);
 out:
-        free_page((unsigned long)data);
+        kfree(env);
         return count;
 }
 
 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
 {
-        size_t len = count;
         enum kobject_action action;
 
-        if (len && buf[len-1] == '\n')
-                len--;
-
-        for (action = 0; action < KOBJ_MAX; action++) {
-                if (strncmp(kobject_actions[action], buf, len) != 0)
-                        continue;
-                if (kobject_actions[action][len] != '\0')
-                        continue;
+        if (kobject_action_type(buf, count, &action) == 0) {
                 kobject_uevent(&dev->kobj, action);
                 goto out;
         }
@@ -449,7 +405,7 @@ static struct device_attribute devt_attr =
  *      devices_subsys - structure to be registered with kobject core.
  */
 
-decl_subsys(devices, &ktype_device, &device_uevent_ops);
+decl_subsys(devices, &device_ktype, &device_uevent_ops);
 
 
 /**
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index b24efd4e3e3d..0295855a3eef 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -88,19 +88,14 @@ static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
 
 static void fw_dev_release(struct device *dev);
 
-static int firmware_uevent(struct device *dev, char **envp, int num_envp,
-                           char *buffer, int buffer_size)
+static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
-        int i = 0, len = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                           "FIRMWARE=%s", fw_priv->fw_id))
+        if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
                 return -ENOMEM;
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                           "TIMEOUT=%i", loading_timeout))
+        if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
                 return -ENOMEM;
-        envp[i] = NULL;
 
         return 0;
 }
@@ -297,8 +292,7 @@ firmware_class_timeout(u_long data)
 
 static inline void fw_setup_device_id(struct device *f_dev, struct device *dev)
 {
-        /* XXX warning we should watch out for name collisions */
-        strlcpy(f_dev->bus_id, dev->bus_id, BUS_ID_SIZE);
+        snprintf(f_dev->bus_id, BUS_ID_SIZE, "firmware-%s", dev->bus_id);
 }
 
 static int fw_register_device(struct device **dev_p, const char *fw_name,
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 74b96795d2f5..cb99daeae936 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -34,8 +34,7 @@ static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
         return MEMORY_CLASS_NAME;
 }
 
-static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                        int num_envp, char *buffer, int buffer_size)
+static int memory_uevent(struct kset *kset, struct kobj_uevent_env *env)
 {
         int retval = 0;
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 869ff8c00146..fb5609241482 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -160,13 +160,8 @@ static void platform_device_release(struct device *dev)
  *
  *      Create a platform device object which can have other objects attached
  *      to it, and which will have attached objects freed when it is released.
- *
- *      This device will be marked as not supporting hotpluggable drivers; no
- *      device add/remove uevents will be generated.  In the unusual case that
- *      the device isn't being dynamically allocated as a legacy "probe the
- *      hardware" driver, infrastructure code should reverse this marking.
  */
-struct platform_device *platform_device_alloc(const char *name, unsigned int id)
+struct platform_device *platform_device_alloc(const char *name, int id)
 {
         struct platform_object *pa;
 
@@ -177,12 +172,6 @@ struct platform_device *platform_device_alloc(const char *name, unsigned int id)
                 pa->pdev.id = id;
                 device_initialize(&pa->pdev.dev);
                 pa->pdev.dev.release = platform_device_release;
-
-                /* prevent hotplug "modprobe $(MODALIAS)" from causing trouble in
-                 * legacy probe-the-hardware drivers, which don't properly split
-                 * out device enumeration logic from drivers.
-                 */
-                pa->pdev.dev.uevent_suppress = 1;
         }
 
         return pa ? &pa->pdev : NULL;
@@ -256,7 +245,8 @@ int platform_device_add(struct platform_device *pdev)
         pdev->dev.bus = &platform_bus_type;
 
         if (pdev->id != -1)
-                snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id);
+                snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,
+                         pdev->id);
         else
                 strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
 
@@ -370,7 +360,7 @@ EXPORT_SYMBOL_GPL(platform_device_unregister);
  *      the Linux driver model.  In particular, when such drivers are built
  *      as modules, they can't be "hotplugged".
  */
-struct platform_device *platform_device_register_simple(char *name, unsigned int id,
+struct platform_device *platform_device_register_simple(char *name, int id,
                                                         struct resource *res, unsigned int num)
 {
         struct platform_device *pdev;
@@ -530,7 +520,7 @@ static ssize_t
 modalias_show(struct device *dev, struct device_attribute *a, char *buf)
 {
         struct platform_device  *pdev = to_platform_device(dev);
-        int len = snprintf(buf, PAGE_SIZE, "%s\n", pdev->name);
+        int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
 
         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 }
@@ -540,13 +530,11 @@ static struct device_attribute platform_dev_attrs[] = {
         __ATTR_NULL,
 };
 
-static int platform_uevent(struct device *dev, char **envp, int num_envp,
-                char *buffer, int buffer_size)
+static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct platform_device  *pdev = to_platform_device(dev);
 
-        envp[0] = buffer;
-        snprintf(buffer, buffer_size, "MODALIAS=%s", pdev->name);
+        add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
         return 0;
 }
 
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 9caeaea753a3..a803733c839e 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,5 +1,5 @@
 obj-y                   := shutdown.o
-obj-$(CONFIG_PM_SLEEP)  += main.o suspend.o resume.o sysfs.o
+obj-$(CONFIG_PM_SLEEP)  += main.o sysfs.o
 obj-$(CONFIG_PM_TRACE)  += trace.o
 
 ifeq ($(CONFIG_DEBUG_DRIVER),y)
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index eb9f38d0aa58..0ab4ab21f564 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -20,19 +20,24 @@
  */
 
 #include <linux/device.h>
+#include <linux/kallsyms.h>
 #include <linux/mutex.h>
+#include <linux/pm.h>
+#include <linux/resume-trace.h>
 
+#include "../base.h"
 #include "power.h"
 
 LIST_HEAD(dpm_active);
-LIST_HEAD(dpm_off);
-LIST_HEAD(dpm_off_irq);
+static LIST_HEAD(dpm_off);
+static LIST_HEAD(dpm_off_irq);
 
-DEFINE_MUTEX(dpm_mtx);
-DEFINE_MUTEX(dpm_list_mtx);
+static DEFINE_MUTEX(dpm_mtx);
+static DEFINE_MUTEX(dpm_list_mtx);
 
 int (*platform_enable_wakeup)(struct device *dev, int is_on);
 
+
 int device_pm_add(struct device *dev)
 {
         int error;
@@ -61,3 +66,334 @@ void device_pm_remove(struct device *dev)
 }
 
 
+/*------------------------- Resume routines -------------------------*/
+
+/**
+ *      resume_device - Restore state for one device.
+ *      @dev:   Device.
+ *
+ */
+
+static int resume_device(struct device * dev)
+{
+        int error = 0;
+
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+
+        down(&dev->sem);
+
+        if (dev->bus && dev->bus->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->bus->resume(dev);
+        }
+
+        if (!error && dev->type && dev->type->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->type->resume(dev);
+        }
+
+        if (!error && dev->class && dev->class->resume) {
+                dev_dbg(dev,"class resume\n");
+                error = dev->class->resume(dev);
+        }
+
+        up(&dev->sem);
+
+        TRACE_RESUME(error);
+        return error;
+}
+
+
+static int resume_device_early(struct device * dev)
+{
+        int error = 0;
+
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+        if (dev->bus && dev->bus->resume_early) {
+                dev_dbg(dev,"EARLY resume\n");
+                error = dev->bus->resume_early(dev);
+        }
+        TRACE_RESUME(error);
+        return error;
+}
+
+/*
+ * Resume the devices that have either not gone through
+ * the late suspend, or that did go through it but also
+ * went through the early resume
+ */
+static void dpm_resume(void)
+{
+        mutex_lock(&dpm_list_mtx);
+        while(!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.next;
+                struct device * dev = to_device(entry);
+
+                get_device(dev);
+                list_move_tail(entry, &dpm_active);
+
+                mutex_unlock(&dpm_list_mtx);
+                resume_device(dev);
+                mutex_lock(&dpm_list_mtx);
+                put_device(dev);
+        }
+        mutex_unlock(&dpm_list_mtx);
+}
+
+
+/**
+ *      device_resume - Restore state of each device in system.
+ *
+ *      Walk the dpm_off list, remove each entry, resume the device,
+ *      then add it to the dpm_active list.
+ */
+
+void device_resume(void)
+{
+        might_sleep();
+        mutex_lock(&dpm_mtx);
+        dpm_resume();
+        mutex_unlock(&dpm_mtx);
+}
+
+EXPORT_SYMBOL_GPL(device_resume);
+
+
+/**
+ *      dpm_power_up - Power on some devices.
+ *
+ *      Walk the dpm_off_irq list and power each device up. This
+ *      is used for devices that required they be powered down with
+ *      interrupts disabled. As devices are powered on, they are moved
+ *      to the dpm_active list.
+ *
+ *      Interrupts must be disabled when calling this.
+ */
+
+static void dpm_power_up(void)
+{
+        while(!list_empty(&dpm_off_irq)) {
+                struct list_head * entry = dpm_off_irq.next;
+                struct device * dev = to_device(entry);
+
+                list_move_tail(entry, &dpm_off);
+                resume_device_early(dev);
+        }
+}
+
+
+/**
+ *      device_power_up - Turn on all devices that need special attention.
+ *
+ *      Power on system devices then devices that required we shut them down
+ *      with interrupts disabled.
+ *      Called with interrupts disabled.
+ */
+
+void device_power_up(void)
+{
+        sysdev_resume();
+        dpm_power_up();
+}
+
+EXPORT_SYMBOL_GPL(device_power_up);
+
+
+/*------------------------- Suspend routines -------------------------*/
+
+/*
+ * The entries in the dpm_active list are in a depth first order, simply
+ * because children are guaranteed to be discovered after parents, and
+ * are inserted at the back of the list on discovery.
+ *
+ * All list on the suspend path are done in reverse order, so we operate
+ * on the leaves of the device tree (or forests, depending on how you want
+ * to look at it ;) first. As nodes are removed from the back of the list,
+ * they are inserted into the front of their destintation lists.
+ *
+ * Things are the reverse on the resume path - iterations are done in
+ * forward order, and nodes are inserted at the back of their destination
+ * lists. This way, the ancestors will be accessed before their descendents.
+ */
+
+static inline char *suspend_verb(u32 event)
+{
+        switch (event) {
+        case PM_EVENT_SUSPEND:  return "suspend";
+        case PM_EVENT_FREEZE:   return "freeze";
+        case PM_EVENT_PRETHAW:  return "prethaw";
+        default:                return "(unknown suspend 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.
+ *      @state: Power state device is entering.
+ */
+
+static int suspend_device(struct device * dev, pm_message_t state)
+{
+        int error = 0;
+
+        down(&dev->sem);
+        if (dev->power.power_state.event) {
+                dev_dbg(dev, "PM: suspend %d-->%d\n",
+                        dev->power.power_state.event, state.event);
+        }
+
+        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) {
+                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) {
+                suspend_device_dbg(dev, state, "");
+                error = dev->bus->suspend(dev, state);
+                suspend_report_result(dev->bus->suspend, error);
+        }
+        up(&dev->sem);
+        return error;
+}
+
+
+/*
+ * This is called with interrupts off, only a single CPU
+ * 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) {
+                suspend_device_dbg(dev, state, "LATE ");
+                error = dev->bus->suspend_late(dev, state);
+                suspend_report_result(dev->bus->suspend_late, error);
+        }
+        return error;
+}
+
+/**
+ *      device_suspend - Save state and stop all devices in system.
+ *      @state:         Power state to put each device in.
+ *
+ *      Walk the dpm_active list, call ->suspend() for each device, and move
+ *      it to the dpm_off list.
+ *
+ *      (For historical reasons, if it returns -EAGAIN, that used to mean
+ *      that the device would be called again with interrupts disabled.
+ *      These days, we use the "suspend_late()" callback for that, so we
+ *      print a warning and consider it an error).
+ *
+ *      If we get a different error, try and back out.
+ *
+ *      If we hit a failure with any of the devices, call device_resume()
+ *      above to bring the suspended devices back to life.
+ *
+ */
+
+int device_suspend(pm_message_t state)
+{
+        int error = 0;
+
+        might_sleep();
+        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);
+                mutex_unlock(&dpm_list_mtx);
+
+                error = suspend_device(dev, state);
+
+                mutex_lock(&dpm_list_mtx);
+
+                /* Check if the device got removed */
+                if (!list_empty(&dev->power.entry)) {
+                        /* Move it to the dpm_off list */
+                        if (!error)
+                                list_move(&dev->power.entry, &dpm_off);
+                }
+                if (error)
+                        printk(KERN_ERR "Could not suspend device %s: "
+                                "error %d%s\n",
+                                kobject_name(&dev->kobj), error,
+                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
+                put_device(dev);
+        }
+        mutex_unlock(&dpm_list_mtx);
+        if (error)
+                dpm_resume();
+
+        mutex_unlock(&dpm_mtx);
+        return error;
+}
+
+EXPORT_SYMBOL_GPL(device_suspend);
+
+/**
+ *      device_power_down - Shut down special devices.
+ *      @state:         Power state to enter.
+ *
+ *      Walk the dpm_off_irq list, calling ->power_down() for each device that
+ *      couldn't power down the device with interrupts enabled. When we're
+ *      done, power down system devices.
+ */
+
+int device_power_down(pm_message_t state)
+{
+        int error = 0;
+        struct device * dev;
+
+        while (!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.prev;
+
+                dev = to_device(entry);
+                error = suspend_device_late(dev, state);
+                if (error)
+                        goto Error;
+                list_move(&dev->power.entry, &dpm_off_irq);
+        }
+
+        error = sysdev_suspend(state);
+ Done:
+        return error;
+ Error:
+        printk(KERN_ERR "Could not power down device %s: "
+                "error %d\n", kobject_name(&dev->kobj), error);
+        dpm_power_up();
+        goto Done;
+}
+
+EXPORT_SYMBOL_GPL(device_power_down);
+
+void __suspend_report_result(const char *function, void *fn, int ret)
+{
+        if (ret) {
+                printk(KERN_ERR "%s(): ", function);
+                print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
+                printk("%d\n", ret);
+        }
+}
+EXPORT_SYMBOL_GPL(__suspend_report_result);
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 8ba0830cbc03..5c4efd493fa5 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -11,32 +11,11 @@ extern void device_shutdown(void);
  * main.c
  */
 
-/*
- * Used to synchronize global power management operations.
- */
-extern struct mutex dpm_mtx;
-
-/*
- * Used to serialize changes to the dpm_* lists.
- */
-extern struct mutex dpm_list_mtx;
-
-/*
- * The PM lists.
- */
-extern struct list_head dpm_active;
-extern struct list_head dpm_off;
-extern struct list_head dpm_off_irq;
-
-
-static inline struct dev_pm_info * to_pm_info(struct list_head * entry)
-{
-        return container_of(entry, struct dev_pm_info, entry);
-}
+extern struct list_head dpm_active;     /* The active device list */
 
 static inline struct device * to_device(struct list_head * entry)
 {
-        return container_of(to_pm_info(entry), struct device, power);
+        return container_of(entry, struct device, power.entry);
 }
 
 extern int device_pm_add(struct device *);
@@ -49,19 +28,6 @@ extern void device_pm_remove(struct device *);
 extern int dpm_sysfs_add(struct device *);
 extern void dpm_sysfs_remove(struct device *);
 
-/*
- * resume.c
- */
-
-extern void dpm_resume(void);
-extern void dpm_power_up(void);
-extern int resume_device(struct device *);
-
-/*
- * suspend.c
- */
-extern int suspend_device(struct device *, pm_message_t);
-
 #else /* CONFIG_PM_SLEEP */
 
 
diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
deleted file mode 100644
index 00fd84ae6e66..000000000000
--- a/drivers/base/power/resume.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * resume.c - Functions for waking devices up.
- *
- * Copyright (c) 2003 Patrick Mochel
- * Copyright (c) 2003 Open Source Development Labs
- *
- * This file is released under the GPLv2
- *
- */
-
-#include <linux/device.h>
-#include <linux/resume-trace.h>
-#include "../base.h"
-#include "power.h"
-
-
-/**
- *      resume_device - Restore state for one device.
- *      @dev:   Device.
- *
- */
-
-int resume_device(struct device * dev)
-{
-        int error = 0;
-
-        TRACE_DEVICE(dev);
-        TRACE_RESUME(0);
-
-        down(&dev->sem);
-
-        if (dev->bus && dev->bus->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->bus->resume(dev);
-        }
-
-        if (!error && dev->type && dev->type->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->type->resume(dev);
-        }
-
-        if (!error && dev->class && dev->class->resume) {
-                dev_dbg(dev,"class resume\n");
-                error = dev->class->resume(dev);
-        }
-
-        up(&dev->sem);
-
-        TRACE_RESUME(error);
-        return error;
-}
-
-
-static int resume_device_early(struct device * dev)
-{
-        int error = 0;
-
-        TRACE_DEVICE(dev);
-        TRACE_RESUME(0);
-        if (dev->bus && dev->bus->resume_early) {
-                dev_dbg(dev,"EARLY resume\n");
-                error = dev->bus->resume_early(dev);
-        }
-        TRACE_RESUME(error);
-        return error;
-}
-
-/*
- * Resume the devices that have either not gone through
- * the late suspend, or that did go through it but also
- * went through the early resume
- */
-void dpm_resume(void)
-{
-        mutex_lock(&dpm_list_mtx);
-        while(!list_empty(&dpm_off)) {
-                struct list_head * entry = dpm_off.next;
-                struct device * dev = to_device(entry);
-
-                get_device(dev);
-                list_move_tail(entry, &dpm_active);
-
-                mutex_unlock(&dpm_list_mtx);
-                resume_device(dev);
-                mutex_lock(&dpm_list_mtx);
-                put_device(dev);
-        }
-        mutex_unlock(&dpm_list_mtx);
-}
-
-
-/**
- *      device_resume - Restore state of each device in system.
- *
- *      Walk the dpm_off list, remove each entry, resume the device,
- *      then add it to the dpm_active list.
- */
-
-void device_resume(void)
-{
-        might_sleep();
-        mutex_lock(&dpm_mtx);
-        dpm_resume();
-        mutex_unlock(&dpm_mtx);
-}
-
-EXPORT_SYMBOL_GPL(device_resume);
-
-
-/**
- *      dpm_power_up - Power on some devices.
- *
- *      Walk the dpm_off_irq list and power each device up. This
- *      is used for devices that required they be powered down with
- *      interrupts disabled. As devices are powered on, they are moved
- *      to the dpm_active list.
- *
- *      Interrupts must be disabled when calling this.
- */
-
-void dpm_power_up(void)
-{
-        while(!list_empty(&dpm_off_irq)) {
-                struct list_head * entry = dpm_off_irq.next;
-                struct device * dev = to_device(entry);
-
-                list_move_tail(entry, &dpm_off);
-                resume_device_early(dev);
-        }
-}
-
-
-/**
- *      device_power_up - Turn on all devices that need special attention.
- *
- *      Power on system devices then devices that required we shut them down
- *      with interrupts disabled.
- *      Called with interrupts disabled.
- */
-
-void device_power_up(void)
-{
-        sysdev_resume();
-        dpm_power_up();
-}
-
-EXPORT_SYMBOL_GPL(device_power_up);
-
-
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
deleted file mode 100644
index 26df9b231737..000000000000
--- a/drivers/base/power/suspend.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * suspend.c - Functions for putting devices to sleep.
- *
- * Copyright (c) 2003 Patrick Mochel
- * Copyright (c) 2003 Open Source Development Labs
- *
- * This file is released under the GPLv2
- *
- */
-
-#include <linux/device.h>
-#include <linux/kallsyms.h>
-#include <linux/pm.h>
-#include "../base.h"
-#include "power.h"
-
-/*
- * The entries in the dpm_active list are in a depth first order, simply
- * because children are guaranteed to be discovered after parents, and
- * are inserted at the back of the list on discovery.
- *
- * All list on the suspend path are done in reverse order, so we operate
- * on the leaves of the device tree (or forests, depending on how you want
- * to look at it ;) first. As nodes are removed from the back of the list,
- * they are inserted into the front of their destintation lists.
- *
- * Things are the reverse on the resume path - iterations are done in
- * forward order, and nodes are inserted at the back of their destination
- * lists. This way, the ancestors will be accessed before their descendents.
- */
-
-static inline char *suspend_verb(u32 event)
-{
-        switch (event) {
-        case PM_EVENT_SUSPEND:  return "suspend";
-        case PM_EVENT_FREEZE:   return "freeze";
-        case PM_EVENT_PRETHAW:  return "prethaw";
-        default:                return "(unknown suspend 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.
- *      @state: Power state device is entering.
- */
-
-int suspend_device(struct device * dev, pm_message_t state)
-{
-        int error = 0;
-
-        down(&dev->sem);
-        if (dev->power.power_state.event) {
-                dev_dbg(dev, "PM: suspend %d-->%d\n",
-                        dev->power.power_state.event, state.event);
-        }
-
-        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) {
-                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) {
-                suspend_device_dbg(dev, state, "");
-                error = dev->bus->suspend(dev, state);
-                suspend_report_result(dev->bus->suspend, error);
-        }
-        up(&dev->sem);
-        return error;
-}
-
-
-/*
- * This is called with interrupts off, only a single CPU
- * 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) {
-                suspend_device_dbg(dev, state, "LATE ");
-                error = dev->bus->suspend_late(dev, state);
-                suspend_report_result(dev->bus->suspend_late, error);
-        }
-        return error;
-}
-
-/**
- *      device_suspend - Save state and stop all devices in system.
- *      @state:         Power state to put each device in.
- *
- *      Walk the dpm_active list, call ->suspend() for each device, and move
- *      it to the dpm_off list.
- *
- *      (For historical reasons, if it returns -EAGAIN, that used to mean
- *      that the device would be called again with interrupts disabled.
- *      These days, we use the "suspend_late()" callback for that, so we
- *      print a warning and consider it an error).
- *
- *      If we get a different error, try and back out.
- *
- *      If we hit a failure with any of the devices, call device_resume()
- *      above to bring the suspended devices back to life.
- *
- */
-
-int device_suspend(pm_message_t state)
-{
-        int error = 0;
-
-        might_sleep();
-        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);
-                mutex_unlock(&dpm_list_mtx);
-
-                error = suspend_device(dev, state);
-
-                mutex_lock(&dpm_list_mtx);
-
-                /* Check if the device got removed */
-                if (!list_empty(&dev->power.entry)) {
-                        /* Move it to the dpm_off list */
-                        if (!error)
-                                list_move(&dev->power.entry, &dpm_off);
-                }
-                if (error)
-                        printk(KERN_ERR "Could not suspend device %s: "
-                                "error %d%s\n",
-                                kobject_name(&dev->kobj), error,
-                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
-                put_device(dev);
-        }
-        mutex_unlock(&dpm_list_mtx);
-        if (error)
-                dpm_resume();
-
-        mutex_unlock(&dpm_mtx);
-        return error;
-}
-
-EXPORT_SYMBOL_GPL(device_suspend);
-
-/**
- *      device_power_down - Shut down special devices.
- *      @state:         Power state to enter.
- *
- *      Walk the dpm_off_irq list, calling ->power_down() for each device that
- *      couldn't power down the device with interrupts enabled. When we're
- *      done, power down system devices.
- */
-
-int device_power_down(pm_message_t state)
-{
-        int error = 0;
-        struct device * dev;
-
-        while (!list_empty(&dpm_off)) {
-                struct list_head * entry = dpm_off.prev;
-
-                dev = to_device(entry);
-                error = suspend_device_late(dev, state);
-                if (error)
-                        goto Error;
-                list_move(&dev->power.entry, &dpm_off_irq);
-        }
-
-        error = sysdev_suspend(state);
- Done:
-        return error;
- Error:
-        printk(KERN_ERR "Could not power down device %s: "
-                "error %d\n", kobject_name(&dev->kobj), error);
-        dpm_power_up();
-        goto Done;
-}
-
-EXPORT_SYMBOL_GPL(device_power_down);
-
-void __suspend_report_result(const char *function, void *fn, int ret)
-{
-        if (ret) {
-                printk(KERN_ERR "%s(): ", function);
-                print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
-                printk("%d\n", ret);
-        }
-}
-EXPORT_SYMBOL_GPL(__suspend_report_result);
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 18febe26caa1..ac7ff6d0c6e5 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -139,7 +139,7 @@ int sysdev_class_register(struct sysdev_class * cls)
                  kobject_name(&cls->kset.kobj));
         INIT_LIST_HEAD(&cls->drivers);
         cls->kset.kobj.parent = &system_subsys.kobj;
-        kset_set_kset_s(cls, system_subsys);
+        cls->kset.kobj.kset = &system_subsys;
         return kset_register(&cls->kset);
 }
 
@@ -153,25 +153,22 @@ void sysdev_class_unregister(struct sysdev_class * cls)
 EXPORT_SYMBOL_GPL(sysdev_class_register);
 EXPORT_SYMBOL_GPL(sysdev_class_unregister);
 
-
-static LIST_HEAD(sysdev_drivers);
 static DEFINE_MUTEX(sysdev_drivers_lock);
 
 /**
  *      sysdev_driver_register - Register auxillary driver
- *      @cls:   Device class driver belongs to.
+ *      @cls:   Device class driver belongs to.
  *      @drv:   Driver.
  *
- *      If @cls is valid, then @drv is inserted into @cls->drivers to be
+ *      @drv is inserted into @cls->drivers to be
  *      called on each operation on devices of that class. The refcount
  *      of @cls is incremented.
- *      Otherwise, @drv is inserted into sysdev_drivers, and called for
- *      each device.
  */
 
-int sysdev_driver_register(struct sysdev_class * cls,
-                           struct sysdev_driver * drv)
+int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 {
+        int err = 0;
+
         mutex_lock(&sysdev_drivers_lock);
         if (cls && kset_get(&cls->kset)) {
                 list_add_tail(&drv->entry, &cls->drivers);
@@ -182,10 +179,13 @@ int sysdev_driver_register(struct sysdev_class * cls,
                         list_for_each_entry(dev, &cls->kset.list, kobj.entry)
                                 drv->add(dev);
                 }
-        } else
-                list_add_tail(&drv->entry, &sysdev_drivers);
+        } else {
+                err = -EINVAL;
+                printk(KERN_ERR "%s: invalid device class\n", __FUNCTION__);
+                WARN_ON(1);
+        }
         mutex_unlock(&sysdev_drivers_lock);
-        return 0;
+        return err;
 }
 
 
@@ -251,12 +251,6 @@ int sysdev_register(struct sys_device * sysdev)
                  * code that should have called us.
                  */
 
-                /* Notify global drivers */
-                list_for_each_entry(drv, &sysdev_drivers, entry) {
-                        if (drv->add)
-                                drv->add(sysdev);
-                }
-
                 /* Notify class auxillary drivers */
                 list_for_each_entry(drv, &cls->drivers, entry) {
                         if (drv->add)
@@ -272,11 +266,6 @@ void sysdev_unregister(struct sys_device * sysdev)
         struct sysdev_driver * drv;
 
         mutex_lock(&sysdev_drivers_lock);
-        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                if (drv->remove)
-                        drv->remove(sysdev);
-        }
-
         list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
                 if (drv->remove)
                         drv->remove(sysdev);
@@ -293,7 +282,7 @@ void sysdev_unregister(struct sys_device * sysdev)
  *
  *      Loop over each class of system devices, and the devices in each
  *      of those classes. For each device, we call the shutdown method for
- *      each driver registered for the device - the globals, the auxillaries,
+ *      each driver registered for the device - the auxillaries,
  *      and the class driver.
  *
  *      Note: The list is iterated in reverse order, so that we shut down
@@ -320,13 +309,7 @@ void sysdev_shutdown(void)
                         struct sysdev_driver * drv;
                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
 
-                        /* Call global drivers first. */
-                        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                                if (drv->shutdown)
-                                        drv->shutdown(sysdev);
-                        }
-
-                        /* Call auxillary drivers next. */
+                        /* Call auxillary drivers first */
                         list_for_each_entry(drv, &cls->drivers, entry) {
                                 if (drv->shutdown)
                                         drv->shutdown(sysdev);
@@ -354,12 +337,6 @@ static void __sysdev_resume(struct sys_device *dev)
                 if (drv->resume)
                         drv->resume(dev);
         }
-
-        /* Call global drivers. */
-        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                if (drv->resume)
-                        drv->resume(dev);
-        }
 }
 
 /**
@@ -393,16 +370,7 @@ int sysdev_suspend(pm_message_t state)
                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
 
-                        /* Call global drivers first. */
-                        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                                if (drv->suspend) {
-                                        ret = drv->suspend(sysdev, state);
-                                        if (ret)
-                                                goto gbl_driver;
-                                }
-                        }
-
-                        /* Call auxillary drivers next. */
+                        /* Call auxillary drivers first */
                         list_for_each_entry(drv, &cls->drivers, entry) {
                                 if (drv->suspend) {
                                         ret = drv->suspend(sysdev, state);
@@ -436,18 +404,7 @@ aux_driver:
                 if (err_drv->resume)
                         err_drv->resume(sysdev);
         }
-        drv = NULL;
 
-gbl_driver:
-        if (drv)
-                printk(KERN_ERR "sysdev driver suspend failed for %s\n",
-                                kobject_name(&sysdev->kobj));
-        list_for_each_entry(err_drv, &sysdev_drivers, entry) {
-                if (err_drv == drv)
-                        break;
-                if (err_drv->resume)
-                        err_drv->resume(sysdev);
-        }
         /* resume other sysdevs in current class */
         list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
                 if (err_dev == sysdev)