PM / Sleep: Add wakeup_source_activate and wakeup_source_deactivate tracepoints
[linux-2.6.git] / drivers / base / attribute_container.c
index 1ec0654..8fc200b 100644 (file)
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 
 #include "base.h"
 
 struct internal_container {
        struct klist_node node;
        struct attribute_container *cont;
-       struct class_device classdev;
+       struct device classdev;
 };
 
 static void internal_container_klist_get(struct klist_node *n)
 {
        struct internal_container *ic =
                container_of(n, struct internal_container, node);
-       class_device_get(&ic->classdev);
+       get_device(&ic->classdev);
 }
 
 static void internal_container_klist_put(struct klist_node *n)
 {
        struct internal_container *ic =
                container_of(n, struct internal_container, node);
-       class_device_put(&ic->classdev);
+       put_device(&ic->classdev);
 }
 
 
@@ -52,7 +53,7 @@ static void internal_container_klist_put(struct klist_node *n)
  * Returns the container associated with this classdev.
  */
 struct attribute_container *
-attribute_container_classdev_to_container(struct class_device *classdev)
+attribute_container_classdev_to_container(struct device *classdev)
 {
        struct internal_container *ic =
                container_of(classdev, struct internal_container, classdev);
@@ -60,7 +61,7 @@ attribute_container_classdev_to_container(struct class_device *classdev)
 }
 EXPORT_SYMBOL_GPL(attribute_container_classdev_to_container);
 
-static struct list_head attribute_container_list;
+static LIST_HEAD(attribute_container_list);
 
 static DEFINE_MUTEX(attribute_container_mutex);
 
@@ -109,11 +110,11 @@ attribute_container_unregister(struct attribute_container *cont)
 EXPORT_SYMBOL_GPL(attribute_container_unregister);
 
 /* private function used as class release */
-static void attribute_container_release(struct class_device *classdev)
+static void attribute_container_release(struct device *classdev)
 {
        struct internal_container *ic 
                = container_of(classdev, struct internal_container, classdev);
-       struct device *dev = classdev->dev;
+       struct device *dev = classdev->parent;
 
        kfree(ic);
        put_device(dev);
@@ -128,12 +129,12 @@ static void attribute_container_release(struct class_device *classdev)
  * This function allocates storage for the class device(s) to be
  * attached to dev (one for each matching attribute_container).  If no
  * fn is provided, the code will simply register the class device via
- * class_device_add.  If a function is provided, it is expected to add
+ * device_add.  If a function is provided, it is expected to add
  * the class device at the appropriate time.  One of the things that
  * might be necessary is to allocate and initialise the classdev and
  * then add it a later time.  To do this, call this routine for
  * allocation and initialisation and then use
- * attribute_container_device_trigger() to call class_device_add() on
+ * attribute_container_device_trigger() to call device_add() on
  * it.  Note: after this, the class device contains a reference to dev
  * which is not relinquished until the release of the classdev.
  */
@@ -141,7 +142,7 @@ void
 attribute_container_add_device(struct device *dev,
                               int (*fn)(struct attribute_container *,
                                         struct device *,
-                                        struct class_device *))
+                                        struct device *))
 {
        struct attribute_container *cont;
 
@@ -162,11 +163,11 @@ attribute_container_add_device(struct device *dev,
                }
 
                ic->cont = cont;
-               class_device_initialize(&ic->classdev);
-               ic->classdev.dev = get_device(dev);
+               device_initialize(&ic->classdev);
+               ic->classdev.parent = get_device(dev);
                ic->classdev.class = cont->class;
-               cont->class->release = attribute_container_release;
-               strcpy(ic->classdev.class_id, dev->bus_id);
+               cont->class->dev_release = attribute_container_release;
+               dev_set_name(&ic->classdev, dev_name(dev));
                if (fn)
                        fn(cont, dev, &ic->classdev);
                else
@@ -194,20 +195,19 @@ attribute_container_add_device(struct device *dev,
  * @fn:          A function to call to remove the device
  *
  * This routine triggers device removal.  If fn is NULL, then it is
- * simply done via class_device_unregister (note that if something
+ * simply done via device_unregister (note that if something
  * still has a reference to the classdev, then the memory occupied
  * will not be freed until the classdev is released).  If you want a
  * two phase release: remove from visibility and then delete the
  * device, then you should use this routine with a fn that calls
- * class_device_del() and then use
- * attribute_container_device_trigger() to do the final put on the
- * classdev.
+ * device_del() and then use attribute_container_device_trigger()
+ * to do the final put on the classdev.
  */
 void
 attribute_container_remove_device(struct device *dev,
                                  void (*fn)(struct attribute_container *,
                                             struct device *,
-                                            struct class_device *))
+                                            struct device *))
 {
        struct attribute_container *cont;
 
@@ -223,14 +223,14 @@ attribute_container_remove_device(struct device *dev,
                        continue;
 
                klist_for_each_entry(ic, &cont->containers, node, &iter) {
-                       if (dev != ic->classdev.dev)
+                       if (dev != ic->classdev.parent)
                                continue;
                        klist_del(&ic->node);
                        if (fn)
                                fn(cont, dev, &ic->classdev);
                        else {
                                attribute_container_remove_attrs(&ic->classdev);
-                               class_device_unregister(&ic->classdev);
+                               device_unregister(&ic->classdev);
                        }
                }
        }
@@ -251,7 +251,7 @@ void
 attribute_container_device_trigger(struct device *dev, 
                                   int (*fn)(struct attribute_container *,
                                             struct device *,
-                                            struct class_device *))
+                                            struct device *))
 {
        struct attribute_container *cont;
 
@@ -269,7 +269,7 @@ attribute_container_device_trigger(struct device *dev,
                }
 
                klist_for_each_entry(ic, &cont->containers, node, &iter) {
-                       if (dev == ic->classdev.dev)
+                       if (dev == ic->classdev.parent)
                                fn(cont, dev, &ic->classdev);
                }
        }
@@ -312,18 +312,24 @@ attribute_container_trigger(struct device *dev,
  * attributes listed in the container
  */
 int
-attribute_container_add_attrs(struct class_device *classdev)
+attribute_container_add_attrs(struct device *classdev)
 {
        struct attribute_container *cont =
                attribute_container_classdev_to_container(classdev);
-       struct class_device_attribute **attrs = cont->attrs;
+       struct device_attribute **attrs = cont->attrs;
        int i, error;
 
-       if (!attrs)
+       BUG_ON(attrs && cont->grp);
+
+       if (!attrs && !cont->grp)
                return 0;
 
+       if (cont->grp)
+               return sysfs_create_group(&classdev->kobj, cont->grp);
+
        for (i = 0; attrs[i]; i++) {
-               error = class_device_create_file(classdev, attrs[i]);
+               sysfs_attr_init(&attrs[i]->attr);
+               error = device_create_file(classdev, attrs[i]);
                if (error)
                        return error;
        }
@@ -332,18 +338,18 @@ attribute_container_add_attrs(struct class_device *classdev)
 }
 
 /**
- * attribute_container_add_class_device - same function as class_device_add
+ * attribute_container_add_class_device - same function as device_add
  *
  * @classdev:  the class device to add
  *
- * This performs essentially the same function as class_device_add except for
+ * This performs essentially the same function as device_add except for
  * attribute containers, namely add the classdev to the system and then
  * create the attribute files
  */
 int
-attribute_container_add_class_device(struct class_device *classdev)
+attribute_container_add_class_device(struct device *classdev)
 {
-       int error = class_device_add(classdev);
+       int error = device_add(classdev);
        if (error)
                return error;
        return attribute_container_add_attrs(classdev);
@@ -358,7 +364,7 @@ attribute_container_add_class_device(struct class_device *classdev)
 int
 attribute_container_add_class_device_adapter(struct attribute_container *cont,
                                             struct device *dev,
-                                            struct class_device *classdev)
+                                            struct device *classdev)
 {
        return attribute_container_add_class_device(classdev);
 }
@@ -370,18 +376,23 @@ attribute_container_add_class_device_adapter(struct attribute_container *cont,
  *
  */
 void
-attribute_container_remove_attrs(struct class_device *classdev)
+attribute_container_remove_attrs(struct device *classdev)
 {
        struct attribute_container *cont =
                attribute_container_classdev_to_container(classdev);
-       struct class_device_attribute **attrs = cont->attrs;
+       struct device_attribute **attrs = cont->attrs;
        int i;
 
-       if (!attrs)
+       if (!attrs && !cont->grp)
                return;
 
+       if (cont->grp) {
+               sysfs_remove_group(&classdev->kobj, cont->grp);
+               return ;
+       }
+
        for (i = 0; attrs[i]; i++)
-               class_device_remove_file(classdev, attrs[i]);
+               device_remove_file(classdev, attrs[i]);
 }
 
 /**
@@ -390,13 +401,13 @@ attribute_container_remove_attrs(struct class_device *classdev)
  * @classdev: the class device
  *
  * This function simply removes all the attribute files and then calls
- * class_device_del.
+ * device_del.
  */
 void
-attribute_container_class_device_del(struct class_device *classdev)
+attribute_container_class_device_del(struct device *classdev)
 {
        attribute_container_remove_attrs(classdev);
-       class_device_del(classdev);
+       device_del(classdev);
 }
 
 /**
@@ -408,16 +419,16 @@ attribute_container_class_device_del(struct class_device *classdev)
  * Looks up the device in the container's list of class devices and returns
  * the corresponding class_device.
  */
-struct class_device *
+struct device *
 attribute_container_find_class_device(struct attribute_container *cont,
                                      struct device *dev)
 {
-       struct class_device *cdev = NULL;
+       struct device *cdev = NULL;
        struct internal_container *ic;
        struct klist_iter iter;
 
        klist_for_each_entry(ic, &cont->containers, node, &iter) {
-               if (ic->classdev.dev == dev) {
+               if (ic->classdev.parent == dev) {
                        cdev = &ic->classdev;
                        /* FIXME: must exit iterator then break */
                        klist_iter_exit(&iter);
@@ -428,10 +439,3 @@ attribute_container_find_class_device(struct attribute_container *cont,
        return cdev;
 }
 EXPORT_SYMBOL_GPL(attribute_container_find_class_device);
-
-int __init
-attribute_container_init(void)
-{
-       INIT_LIST_HEAD(&attribute_container_list);
-       return 0;
-}