Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6: (36 commits)
  SCSI: convert struct class_device to struct device
  DRM: remove unused dev_class
  IB: rename "dev" to "srp_dev" in srp_host structure
  IB: convert struct class_device to struct device
  memstick: convert struct class_device to struct device
  driver core: replace remaining __FUNCTION__ occurrences
  sysfs: refill attribute buffer when reading from offset 0
  PM: Remove destroy_suspended_device()
  Firmware: add iSCSI iBFT Support
  PM: Remove legacy PM (fix)
  Kobject: Replace list_for_each() with list_for_each_entry().
  SYSFS: Explicitly include required header file slab.h.
  Driver core: make device_is_registered() work for class devices
  PM: Convert wakeup flag accessors to inline functions
  PM: Make wakeup flags available whenever CONFIG_PM is set
  PM: Fix misuse of wakeup flag accessors in serial core
  Driver core: Call device_pm_add() after bus_add_device() in device_add()
  PM: Handle device registrations during suspend/resume
  block: send disk "change" event for rescan_partitions()
  sysdev: detect multiple driver registrations
  ...

Fixed trivial conflict in include/linux/memory.h due to semaphore header
file change (made irrelevant by the change to mutex).

1 files changed, 64 insertions, 54 deletions

diff --git a/drivers/misc/enclosure.c b/drivers/misc/enclosure.c
index 6fcb0e96adf4..fafb57fed761 100644
--- a/drivers/misc/enclosure.c
+++ b/drivers/misc/enclosure.c
@@ -40,16 +40,16 @@ static struct class enclosure_component_class;
  * Looks through the list of registered enclosures to see
  * if it can find a match for a device.  Returns NULL if no
  * enclosure is found. Obtains a reference to the enclosure class
- * device which must be released with class_device_put().
+ * device which must be released with device_put().
  */
 struct enclosure_device *enclosure_find(struct device *dev)
 {
-        struct enclosure_device *edev = NULL;
+        struct enclosure_device *edev;
 
         mutex_lock(&container_list_lock);
         list_for_each_entry(edev, &container_list, node) {
-                if (edev->cdev.dev == dev) {
-                        class_device_get(&edev->cdev);
+                if (edev->edev.parent == dev) {
+                        get_device(&edev->edev);
                         mutex_unlock(&container_list_lock);
                         return edev;
                 }
@@ -117,11 +117,11 @@ enclosure_register(struct device *dev, const char *name, int components,
 
         edev->components = components;
 
-        edev->cdev.class = &enclosure_class;
-        edev->cdev.dev = get_device(dev);
+        edev->edev.class = &enclosure_class;
+        edev->edev.parent = get_device(dev);
         edev->cb = cb;
-        snprintf(edev->cdev.class_id, BUS_ID_SIZE, "%s", name);
-        err = class_device_register(&edev->cdev);
+        snprintf(edev->edev.bus_id, BUS_ID_SIZE, "%s", name);
+        err = device_register(&edev->edev);
         if (err)
                 goto err;
 
@@ -135,7 +135,7 @@ enclosure_register(struct device *dev, const char *name, int components,
         return edev;
 
  err:
-        put_device(edev->cdev.dev);
+        put_device(edev->edev.parent);
         kfree(edev);
         return ERR_PTR(err);
 }
@@ -158,27 +158,28 @@ void enclosure_unregister(struct enclosure_device *edev)
 
         for (i = 0; i < edev->components; i++)
                 if (edev->component[i].number != -1)
-                        class_device_unregister(&edev->component[i].cdev);
+                        device_unregister(&edev->component[i].cdev);
 
         /* prevent any callbacks into service user */
         edev->cb = &enclosure_null_callbacks;
-        class_device_unregister(&edev->cdev);
+        device_unregister(&edev->edev);
 }
 EXPORT_SYMBOL_GPL(enclosure_unregister);
 
-static void enclosure_release(struct class_device *cdev)
+static void enclosure_release(struct device *cdev)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev);
 
-        put_device(cdev->dev);
+        put_device(cdev->parent);
         kfree(edev);
 }
 
-static void enclosure_component_release(struct class_device *cdev)
+static void enclosure_component_release(struct device *dev)
 {
-        if (cdev->dev)
-                put_device(cdev->dev);
-        class_device_put(cdev->parent);
+        struct enclosure_component *cdev = to_enclosure_component(dev);
+
+        put_device(cdev->dev);
+        put_device(dev->parent);
 }
 
 /**
@@ -201,7 +202,7 @@ enclosure_component_register(struct enclosure_device *edev,
                              const char *name)
 {
         struct enclosure_component *ecomp;
-        struct class_device *cdev;
+        struct device *cdev;
         int err;
 
         if (number >= edev->components)
@@ -215,14 +216,14 @@ enclosure_component_register(struct enclosure_device *edev,
         ecomp->type = type;
         ecomp->number = number;
         cdev = &ecomp->cdev;
-        cdev->parent = class_device_get(&edev->cdev);
+        cdev->parent = get_device(&edev->edev);
         cdev->class = &enclosure_component_class;
         if (name)
-                snprintf(cdev->class_id, BUS_ID_SIZE, "%s", name);
+                snprintf(cdev->bus_id, BUS_ID_SIZE, "%s", name);
         else
-                snprintf(cdev->class_id, BUS_ID_SIZE, "%u", number);
+                snprintf(cdev->bus_id, BUS_ID_SIZE, "%u", number);
 
-        err = class_device_register(cdev);
+        err = device_register(cdev);
         if (err)
                 ERR_PTR(err);
 
@@ -247,18 +248,17 @@ EXPORT_SYMBOL_GPL(enclosure_component_register);
 int enclosure_add_device(struct enclosure_device *edev, int component,
                          struct device *dev)
 {
-        struct class_device *cdev;
+        struct enclosure_component *cdev;
 
         if (!edev || component >= edev->components)
                 return -EINVAL;
 
-        cdev = &edev->component[component].cdev;
+        cdev = &edev->component[component];
 
-        class_device_del(cdev);
-        if (cdev->dev)
-                put_device(cdev->dev);
+        device_del(&cdev->cdev);
+        put_device(cdev->dev);
         cdev->dev = get_device(dev);
-        return class_device_add(cdev);
+        return device_add(&cdev->cdev);
 }
 EXPORT_SYMBOL_GPL(enclosure_add_device);
 
@@ -272,18 +272,17 @@ EXPORT_SYMBOL_GPL(enclosure_add_device);
  */
 int enclosure_remove_device(struct enclosure_device *edev, int component)
 {
-        struct class_device *cdev;
+        struct enclosure_component *cdev;
 
         if (!edev || component >= edev->components)
                 return -EINVAL;
 
-        cdev = &edev->component[component].cdev;
+        cdev = &edev->component[component];
 
-        class_device_del(cdev);
-        if (cdev->dev)
-                put_device(cdev->dev);
+        device_del(&cdev->cdev);
+        put_device(cdev->dev);
         cdev->dev = NULL;
-        return class_device_add(cdev);
+        return device_add(&cdev->cdev);
 }
 EXPORT_SYMBOL_GPL(enclosure_remove_device);
 
@@ -291,14 +290,16 @@ EXPORT_SYMBOL_GPL(enclosure_remove_device);
  * sysfs pieces below
  */
 
-static ssize_t enclosure_show_components(struct class_device *cdev, char *buf)
+static ssize_t enclosure_show_components(struct device *cdev,
+                                         struct device_attribute *attr,
+                                         char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev);
 
         return snprintf(buf, 40, "%d\n", edev->components);
 }
 
-static struct class_device_attribute enclosure_attrs[] = {
+static struct device_attribute enclosure_attrs[] = {
         __ATTR(components, S_IRUGO, enclosure_show_components, NULL),
         __ATTR_NULL
 };
@@ -306,8 +307,8 @@ static struct class_device_attribute enclosure_attrs[] = {
 static struct class enclosure_class = {
         .name                   = "enclosure",
         .owner                  = THIS_MODULE,
-        .release                = enclosure_release,
-        .class_dev_attrs        = enclosure_attrs,
+        .dev_release            = enclosure_release,
+        .dev_attrs              = enclosure_attrs,
 };
 
 static const char *const enclosure_status [] = {
@@ -326,7 +327,8 @@ static const char *const enclosure_type [] = {
         [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device",
 };
 
-static ssize_t get_component_fault(struct class_device *cdev, char *buf)
+static ssize_t get_component_fault(struct device *cdev,
+                                   struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -336,8 +338,9 @@ static ssize_t get_component_fault(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->fault);
 }
 
-static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_fault(struct device *cdev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -348,7 +351,8 @@ static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_status(struct class_device *cdev, char *buf)
+static ssize_t get_component_status(struct device *cdev,
+                                    struct device_attribute *attr,char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -358,8 +362,9 @@ static ssize_t get_component_status(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]);
 }
 
-static ssize_t set_component_status(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_status(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -380,7 +385,8 @@ static ssize_t set_component_status(struct class_device *cdev, const char *buf,
                 return -EINVAL;
 }
 
-static ssize_t get_component_active(struct class_device *cdev, char *buf)
+static ssize_t get_component_active(struct device *cdev,
+                                    struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -390,8 +396,9 @@ static ssize_t get_component_active(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->active);
 }
 
-static ssize_t set_component_active(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_active(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -402,7 +409,8 @@ static ssize_t set_component_active(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_locate(struct class_device *cdev, char *buf)
+static ssize_t get_component_locate(struct device *cdev,
+                                    struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -412,8 +420,9 @@ static ssize_t get_component_locate(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->locate);
 }
 
-static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_locate(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -424,7 +433,8 @@ static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_type(struct class_device *cdev, char *buf)
+static ssize_t get_component_type(struct device *cdev,
+                                  struct device_attribute *attr, char *buf)
 {
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 
@@ -432,7 +442,7 @@ static ssize_t get_component_type(struct class_device *cdev, char *buf)
 }
 
 
-static struct class_device_attribute enclosure_component_attrs[] = {
+static struct device_attribute enclosure_component_attrs[] = {
         __ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
                set_component_fault),
         __ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
@@ -448,8 +458,8 @@ static struct class_device_attribute enclosure_component_attrs[] = {
 static struct class enclosure_component_class =  {
         .name                   = "enclosure_component",
         .owner                  = THIS_MODULE,
-        .class_dev_attrs        = enclosure_component_attrs,
-        .release                = enclosure_component_release,
+        .dev_attrs      = enclosure_component_attrs,
+        .dev_release            = enclosure_component_release,
 };
 
 static int __init enclosure_init(void)