Network: convert network devices to use struct device instead of class_device

This lets the network core have the ability to handle suspend/resume
issues, if it wants to.

Thanks to Frederik Deweerdt <frederik.deweerdt@gmail.com> for the arm
driver fixes.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

6 files changed, 226 insertions, 195 deletions

diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index 55bb2634c08..2b7c2c7dad4 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -286,7 +286,7 @@ static struct net_bridge_port *new_nbp(struct net_bridge *br,
         kobject_init(&p->kobj);
         kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR);
         p->kobj.ktype = &brport_ktype;
-        p->kobj.parent = &(dev->class_dev.kobj);
+        p->kobj.parent = &(dev->dev.kobj);
         p->kobj.kset = NULL;
 
         return p;
diff --git a/net/bridge/br_sysfs_br.c b/net/bridge/br_sysfs_br.c
index de9d1a9473f..ce10464716a 100644
--- a/net/bridge/br_sysfs_br.c
+++ b/net/bridge/br_sysfs_br.c
@@ -21,18 +21,17 @@
 
 #include "br_private.h"
 
-#define to_class_dev(obj) container_of(obj,struct class_device,kobj)
-#define to_net_dev(class) container_of(class, struct net_device, class_dev)
+#define to_dev(obj)     container_of(obj, struct device, kobj)
 #define to_bridge(cd)   ((struct net_bridge *)(to_net_dev(cd)->priv))
 
 /*
  * Common code for storing bridge parameters.
  */
-static ssize_t store_bridge_parm(struct class_device *cd,
+static ssize_t store_bridge_parm(struct device *d,
                                  const char *buf, size_t len,
                                  void (*set)(struct net_bridge *, unsigned long))
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         char *endp;
         unsigned long val;
 
@@ -50,9 +49,10 @@ static ssize_t store_bridge_parm(struct class_device *cd,
 }
 
 
-static ssize_t show_forward_delay(struct class_device *cd, char *buf)
+static ssize_t show_forward_delay(struct device *d,
+                                  struct device_attribute *attr, char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
 }
 
@@ -64,18 +64,20 @@ static void set_forward_delay(struct net_bridge *br, unsigned long val)
                 br->bridge_forward_delay = delay;
 }
 
-static ssize_t store_forward_delay(struct class_device *cd, const char *buf,
-                                   size_t len)
+static ssize_t store_forward_delay(struct device *d,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_forward_delay);
+        return store_bridge_parm(d, buf, len, set_forward_delay);
 }
-static CLASS_DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
-                         show_forward_delay, store_forward_delay);
+static DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
+                   show_forward_delay, store_forward_delay);
 
-static ssize_t show_hello_time(struct class_device *cd, char *buf)
+static ssize_t show_hello_time(struct device *d, struct device_attribute *attr,
+                               char *buf)
 {
         return sprintf(buf, "%lu\n",
-                       jiffies_to_clock_t(to_bridge(cd)->hello_time));
+                       jiffies_to_clock_t(to_bridge(d)->hello_time));
 }
 
 static void set_hello_time(struct net_bridge *br, unsigned long val)
@@ -86,19 +88,20 @@ static void set_hello_time(struct net_bridge *br, unsigned long val)
                 br->bridge_hello_time = t;
 }
 
-static ssize_t store_hello_time(struct class_device *cd, const char *buf,
+static ssize_t store_hello_time(struct device *d,
+                                struct device_attribute *attr, const char *buf,
                                 size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_hello_time);
+        return store_bridge_parm(d, buf, len, set_hello_time);
 }
+static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
+                   store_hello_time);
 
-static CLASS_DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
-                         store_hello_time);
-
-static ssize_t show_max_age(struct class_device *cd, char *buf)
+static ssize_t show_max_age(struct device *d, struct device_attribute *attr,
+                            char *buf)
 {
         return sprintf(buf, "%lu\n",
-                       jiffies_to_clock_t(to_bridge(cd)->max_age));
+                       jiffies_to_clock_t(to_bridge(d)->max_age));
 }
 
 static void set_max_age(struct net_bridge *br, unsigned long val)
@@ -109,18 +112,17 @@ static void set_max_age(struct net_bridge *br, unsigned long val)
                 br->bridge_max_age = t;
 }
 
-static ssize_t store_max_age(struct class_device *cd, const char *buf,
-                                size_t len)
+static ssize_t store_max_age(struct device *d, struct device_attribute *attr,
+                             const char *buf, size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_max_age);
+        return store_bridge_parm(d, buf, len, set_max_age);
 }
+static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);
 
-static CLASS_DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age,
-                         store_max_age);
-
-static ssize_t show_ageing_time(struct class_device *cd, char *buf)
+static ssize_t show_ageing_time(struct device *d,
+                                struct device_attribute *attr, char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
 }
 
@@ -129,17 +131,19 @@ static void set_ageing_time(struct net_bridge *br, unsigned long val)
         br->ageing_time = clock_t_to_jiffies(val);
 }
 
-static ssize_t store_ageing_time(struct class_device *cd, const char *buf,
-                                 size_t len)
+static ssize_t store_ageing_time(struct device *d,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_ageing_time);
+        return store_bridge_parm(d, buf, len, set_ageing_time);
 }
+static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
+                   store_ageing_time);
 
-static CLASS_DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
-                         store_ageing_time);
-static ssize_t show_stp_state(struct class_device *cd, char *buf)
+static ssize_t show_stp_state(struct device *d,
+                              struct device_attribute *attr, char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%d\n", br->stp_enabled);
 }
 
@@ -148,18 +152,19 @@ static void set_stp_state(struct net_bridge *br, unsigned long val)
         br->stp_enabled = val;
 }
 
-static ssize_t store_stp_state(struct class_device *cd,
-                               const char *buf, size_t len)
+static ssize_t store_stp_state(struct device *d,
+                               struct device_attribute *attr, const char *buf,
+                               size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_stp_state);
+        return store_bridge_parm(d, buf, len, set_stp_state);
 }
+static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
+                   store_stp_state);
 
-static CLASS_DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
-                         store_stp_state);
-
-static ssize_t show_priority(struct class_device *cd, char *buf)
+static ssize_t show_priority(struct device *d, struct device_attribute *attr,
+                             char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%d\n",
                        (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
 }
@@ -169,92 +174,107 @@ static void set_priority(struct net_bridge *br, unsigned long val)
         br_stp_set_bridge_priority(br, (u16) val);
 }
 
-static ssize_t store_priority(struct class_device *cd,
+static ssize_t store_priority(struct device *d, struct device_attribute *attr,
                                const char *buf, size_t len)
 {
-        return store_bridge_parm(cd, buf, len, set_priority);
+        return store_bridge_parm(d, buf, len, set_priority);
 }
-static CLASS_DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority,
-                         store_priority);
+static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);
 
-static ssize_t show_root_id(struct class_device *cd, char *buf)
+static ssize_t show_root_id(struct device *d, struct device_attribute *attr,
+                            char *buf)
 {
-        return br_show_bridge_id(buf, &to_bridge(cd)->designated_root);
+        return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
 }
-static CLASS_DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
+static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
 
-static ssize_t show_bridge_id(struct class_device *cd, char *buf)
+static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr,
+                              char *buf)
 {
-        return br_show_bridge_id(buf, &to_bridge(cd)->bridge_id);
+        return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
 }
-static CLASS_DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
+static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
 
-static ssize_t show_root_port(struct class_device *cd, char *buf)
+static ssize_t show_root_port(struct device *d, struct device_attribute *attr,
+                              char *buf)
 {
-        return sprintf(buf, "%d\n", to_bridge(cd)->root_port);
+        return sprintf(buf, "%d\n", to_bridge(d)->root_port);
 }
-static CLASS_DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
+static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
 
-static ssize_t show_root_path_cost(struct class_device *cd, char *buf)
+static ssize_t show_root_path_cost(struct device *d,
+                                   struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%d\n", to_bridge(cd)->root_path_cost);
+        return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
 }
-static CLASS_DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
+static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
 
-static ssize_t show_topology_change(struct class_device *cd, char *buf)
+static ssize_t show_topology_change(struct device *d,
+                                    struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%d\n", to_bridge(cd)->topology_change);
+        return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
 }
-static CLASS_DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
+static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
 
-static ssize_t show_topology_change_detected(struct class_device *cd, char *buf)
+static ssize_t show_topology_change_detected(struct device *d,
+                                             struct device_attribute *attr,
+                                             char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%d\n", br->topology_change_detected);
 }
-static CLASS_DEVICE_ATTR(topology_change_detected, S_IRUGO, show_topology_change_detected, NULL);
+static DEVICE_ATTR(topology_change_detected, S_IRUGO,
+                   show_topology_change_detected, NULL);
 
-static ssize_t show_hello_timer(struct class_device *cd, char *buf)
+static ssize_t show_hello_timer(struct device *d,
+                                struct device_attribute *attr, char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
 }
-static CLASS_DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
+static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
 
-static ssize_t show_tcn_timer(struct class_device *cd, char *buf)
+static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr,
+                              char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
 }
-static CLASS_DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
+static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
 
-static ssize_t show_topology_change_timer(struct class_device *cd, char *buf)
+static ssize_t show_topology_change_timer(struct device *d,
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
 }
-static CLASS_DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer, NULL);
+static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
+                   NULL);
 
-static ssize_t show_gc_timer(struct class_device *cd, char *buf)
+static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr,
+                             char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
 }
-static CLASS_DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
+static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
 
-static ssize_t show_group_addr(struct class_device *cd, char *buf)
+static ssize_t show_group_addr(struct device *d,
+                               struct device_attribute *attr, char *buf)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
                        br->group_addr[0], br->group_addr[1],
                        br->group_addr[2], br->group_addr[3],
                        br->group_addr[4], br->group_addr[5]);
 }
 
-static ssize_t store_group_addr(struct class_device *cd, const char *buf,
-                                    size_t len)
+static ssize_t store_group_addr(struct device *d,
+                                struct device_attribute *attr,
+                                const char *buf, size_t len)
 {
-        struct net_bridge *br = to_bridge(cd);
+        struct net_bridge *br = to_bridge(d);
         unsigned new_addr[6];
         int i;
 
@@ -286,28 +306,28 @@ static ssize_t store_group_addr(struct class_device *cd, const char *buf,
         return len;
 }
 
-static CLASS_DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
-                         show_group_addr, store_group_addr);
+static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
+                   show_group_addr, store_group_addr);
 
 
 static struct attribute *bridge_attrs[] = {
-        &class_device_attr_forward_delay.attr,
-        &class_device_attr_hello_time.attr,
-        &class_device_attr_max_age.attr,
-        &class_device_attr_ageing_time.attr,
-        &class_device_attr_stp_state.attr,
-        &class_device_attr_priority.attr,
-        &class_device_attr_bridge_id.attr,
-        &class_device_attr_root_id.attr,
-        &class_device_attr_root_path_cost.attr,
-        &class_device_attr_root_port.attr,
-        &class_device_attr_topology_change.attr,
-        &class_device_attr_topology_change_detected.attr,
-        &class_device_attr_hello_timer.attr,
-        &class_device_attr_tcn_timer.attr,
-        &class_device_attr_topology_change_timer.attr,
-        &class_device_attr_gc_timer.attr,
-        &class_device_attr_group_addr.attr,
+        &dev_attr_forward_delay.attr,
+        &dev_attr_hello_time.attr,
+        &dev_attr_max_age.attr,
+        &dev_attr_ageing_time.attr,
+        &dev_attr_stp_state.attr,
+        &dev_attr_priority.attr,
+        &dev_attr_bridge_id.attr,
+        &dev_attr_root_id.attr,
+        &dev_attr_root_path_cost.attr,
+        &dev_attr_root_port.attr,
+        &dev_attr_topology_change.attr,
+        &dev_attr_topology_change_detected.attr,
+        &dev_attr_hello_timer.attr,
+        &dev_attr_tcn_timer.attr,
+        &dev_attr_topology_change_timer.attr,
+        &dev_attr_gc_timer.attr,
+        &dev_attr_group_addr.attr,
         NULL
 };
 
@@ -325,8 +345,8 @@ static struct attribute_group bridge_group = {
 static ssize_t brforward_read(struct kobject *kobj, char *buf,
                            loff_t off, size_t count)
 {
-        struct class_device *cdev = to_class_dev(kobj);
-        struct net_bridge *br = to_bridge(cdev);
+        struct device *dev = to_dev(kobj);
+        struct net_bridge *br = to_bridge(dev);
         int n;
 
         /* must read whole records */
@@ -363,7 +383,7 @@ static struct bin_attribute bridge_forward = {
  */
 int br_sysfs_addbr(struct net_device *dev)
 {
-        struct kobject *brobj = &dev->class_dev.kobj;
+        struct kobject *brobj = &dev->dev.kobj;
         struct net_bridge *br = netdev_priv(dev);
         int err;
 
@@ -395,9 +415,9 @@ int br_sysfs_addbr(struct net_device *dev)
         }
         return 0;
  out3:
-        sysfs_remove_bin_file(&dev->class_dev.kobj, &bridge_forward);
+        sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
  out2:
-        sysfs_remove_group(&dev->class_dev.kobj, &bridge_group);
+        sysfs_remove_group(&dev->dev.kobj, &bridge_group);
  out1:
         return err;
 
@@ -405,7 +425,7 @@ int br_sysfs_addbr(struct net_device *dev)
 
 void br_sysfs_delbr(struct net_device *dev)
 {
-        struct kobject *kobj = &dev->class_dev.kobj;
+        struct kobject *kobj = &dev->dev.kobj;
         struct net_bridge *br = netdev_priv(dev);
 
         kobject_unregister(&br->ifobj);
diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c
index c51c9e42aeb..0bc2aef8f9f 100644
--- a/net/bridge/br_sysfs_if.c
+++ b/net/bridge/br_sysfs_if.c
@@ -211,7 +211,7 @@ int br_sysfs_addif(struct net_bridge_port *p)
         struct brport_attribute **a;
         int err;
 
-        err = sysfs_create_link(&p->kobj, &br->dev->class_dev.kobj, 
+        err = sysfs_create_link(&p->kobj, &br->dev->dev.kobj,
                                 SYSFS_BRIDGE_PORT_LINK);
         if (err)
                 goto out2;
diff --git a/net/core/dev.c b/net/core/dev.c
index e660cb57e42..455d589683e 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -751,7 +751,7 @@ int dev_change_name(struct net_device *dev, char *newname)
         else
                 strlcpy(dev->name, newname, IFNAMSIZ);
 
-        err = class_device_rename(&dev->class_dev, dev->name);
+        err = device_rename(&dev->dev, dev->name);
         if (!err) {
                 hlist_del(&dev->name_hlist);
                 hlist_add_head(&dev->name_hlist, dev_name_hash(dev->name));
@@ -3221,8 +3221,8 @@ void free_netdev(struct net_device *dev)
         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
         dev->reg_state = NETREG_RELEASED;
 
-        /* will free via class release */
-        class_device_put(&dev->class_dev);
+        /* will free via device release */
+        put_device(&dev->dev);
 #else
         kfree((char *)dev - dev->padded);
 #endif
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index f47f319bb7d..44db095a8f7 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -18,9 +18,6 @@
 #include <linux/wireless.h>
 #include <net/iw_handler.h>
 
-#define to_class_dev(obj) container_of(obj,struct class_device,kobj)
-#define to_net_dev(class) container_of(class, struct net_device, class_dev)
-
 static const char fmt_hex[] = "%#x\n";
 static const char fmt_long_hex[] = "%#lx\n";
 static const char fmt_dec[] = "%d\n";
@@ -32,10 +29,11 @@ static inline int dev_isalive(const struct net_device *dev)
 }
 
 /* use same locking rules as GIF* ioctl's */
-static ssize_t netdev_show(const struct class_device *cd, char *buf,
+static ssize_t netdev_show(const struct device *dev,
+                           struct device_attribute *attr, char *buf,
                            ssize_t (*format)(const struct net_device *, char *))
 {
-        struct net_device *net = to_net_dev(cd);
+        struct net_device *net = to_net_dev(dev);
         ssize_t ret = -EINVAL;
 
         read_lock(&dev_base_lock);
@@ -52,14 +50,15 @@ static ssize_t format_##field(const struct net_device *net, char *buf)	\
 {                                                                       \
         return sprintf(buf, format_string, net->field);                 \
 }                                                                       \
-static ssize_t show_##field(struct class_device *cd, char *buf)         \
+static ssize_t show_##field(struct device *dev,                         \
+                            struct device_attribute *attr, char *buf)   \
 {                                                                       \
-        return netdev_show(cd, buf, format_##field);                    \
+        return netdev_show(dev, attr, buf, format_##field);             \
 }
 
 
 /* use same locking and permission rules as SIF* ioctl's */
-static ssize_t netdev_store(struct class_device *dev,
+static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t len,
                             int (*set)(struct net_device *, unsigned long))
 {
@@ -104,7 +103,8 @@ static ssize_t format_addr(char *buf, const unsigned char *addr, int len)
         return cp - buf;
 }
 
-static ssize_t show_address(struct class_device *dev, char *buf)
+static ssize_t show_address(struct device *dev, struct device_attribute *attr,
+                            char *buf)
 {
         struct net_device *net = to_net_dev(dev);
         ssize_t ret = -EINVAL;
@@ -116,7 +116,8 @@ static ssize_t show_address(struct class_device *dev, char *buf)
         return ret;
 }
 
-static ssize_t show_broadcast(struct class_device *dev, char *buf)
+static ssize_t show_broadcast(struct device *dev,
+                            struct device_attribute *attr, char *buf)
 {
         struct net_device *net = to_net_dev(dev);
         if (dev_isalive(net))
@@ -124,7 +125,8 @@ static ssize_t show_broadcast(struct class_device *dev, char *buf)
         return -EINVAL;
 }
 
-static ssize_t show_carrier(struct class_device *dev, char *buf)
+static ssize_t show_carrier(struct device *dev,
+                            struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
         if (netif_running(netdev)) {
@@ -133,7 +135,8 @@ static ssize_t show_carrier(struct class_device *dev, char *buf)
         return -EINVAL;
 }
 
-static ssize_t show_dormant(struct class_device *dev, char *buf)
+static ssize_t show_dormant(struct device *dev,
+                            struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
 
@@ -153,7 +156,8 @@ static const char *operstates[] = {
         "up"
 };
 
-static ssize_t show_operstate(struct class_device *dev, char *buf)
+static ssize_t show_operstate(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
         const struct net_device *netdev = to_net_dev(dev);
         unsigned char operstate;
@@ -178,9 +182,10 @@ static int change_mtu(struct net_device *net, unsigned long new_mtu)
         return dev_set_mtu(net, (int) new_mtu);
 }
 
-static ssize_t store_mtu(struct class_device *dev, const char *buf, size_t len)
+static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
+                         const char *buf, size_t len)
 {
-        return netdev_store(dev, buf, len, change_mtu);
+        return netdev_store(dev, attr, buf, len, change_mtu);
 }
 
 NETDEVICE_SHOW(flags, fmt_hex);
@@ -190,9 +195,10 @@ static int change_flags(struct net_device *net, unsigned long new_flags)
         return dev_change_flags(net, (unsigned) new_flags);
 }
 
-static ssize_t store_flags(struct class_device *dev, const char *buf, size_t len)
+static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t len)
 {
-        return netdev_store(dev, buf, len, change_flags);
+        return netdev_store(dev, attr, buf, len, change_flags);
 }
 
 NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
@@ -203,9 +209,11 @@ static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
         return 0;
 }
 
-static ssize_t store_tx_queue_len(struct class_device *dev, const char *buf, size_t len)
+static ssize_t store_tx_queue_len(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t len)
 {
-        return netdev_store(dev, buf, len, change_tx_queue_len);
+        return netdev_store(dev, attr, buf, len, change_tx_queue_len);
 }
 
 NETDEVICE_SHOW(weight, fmt_dec);
@@ -216,12 +224,13 @@ static int change_weight(struct net_device *net, unsigned long new_weight)
         return 0;
 }
 
-static ssize_t store_weight(struct class_device *dev, const char *buf, size_t len)
+static ssize_t store_weight(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t len)
 {
-        return netdev_store(dev, buf, len, change_weight);
+        return netdev_store(dev, attr, buf, len, change_weight);
 }
 
-static struct class_device_attribute net_class_attributes[] = {
+static struct device_attribute net_class_attributes[] = {
         __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
         __ATTR(iflink, S_IRUGO, show_iflink, NULL),
         __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
@@ -242,10 +251,11 @@ static struct class_device_attribute net_class_attributes[] = {
 };
 
 /* Show a given an attribute in the statistics group */
-static ssize_t netstat_show(const struct class_device *cd, char *buf, 
+static ssize_t netstat_show(const struct device *d,
+                            struct device_attribute *attr, char *buf,
                             unsigned long offset)
 {
-        struct net_device *dev = to_net_dev(cd);
+        struct net_device *dev = to_net_dev(d);
         struct net_device_stats *stats;
         ssize_t ret = -EINVAL;
 
@@ -265,12 +275,13 @@ static ssize_t netstat_show(const struct class_device *cd, char *buf,
 
 /* generate a read-only statistics attribute */
 #define NETSTAT_ENTRY(name)                                             \
-static ssize_t show_##name(struct class_device *cd, char *buf)          \
+static ssize_t show_##name(struct device *d,                            \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
-        return netstat_show(cd, buf,                                    \
+        return netstat_show(d, attr, buf,                               \
                             offsetof(struct net_device_stats, name));   \
 }                                                                       \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
 
 NETSTAT_ENTRY(rx_packets);
 NETSTAT_ENTRY(tx_packets);
@@ -297,29 +308,29 @@ NETSTAT_ENTRY(rx_compressed);
 NETSTAT_ENTRY(tx_compressed);
 
 static struct attribute *netstat_attrs[] = {
-        &class_device_attr_rx_packets.attr,
-        &class_device_attr_tx_packets.attr,
-        &class_device_attr_rx_bytes.attr,
-        &class_device_attr_tx_bytes.attr,
-        &class_device_attr_rx_errors.attr,
-        &class_device_attr_tx_errors.attr,
-        &class_device_attr_rx_dropped.attr,
-        &class_device_attr_tx_dropped.attr,
-        &class_device_attr_multicast.attr,
-        &class_device_attr_collisions.attr,
-        &class_device_attr_rx_length_errors.attr,
-        &class_device_attr_rx_over_errors.attr,
-        &class_device_attr_rx_crc_errors.attr,
-        &class_device_attr_rx_frame_errors.attr,
-        &class_device_attr_rx_fifo_errors.attr,
-        &class_device_attr_rx_missed_errors.attr,
-        &class_device_attr_tx_aborted_errors.attr,
-        &class_device_attr_tx_carrier_errors.attr,
-        &class_device_attr_tx_fifo_errors.attr,
-        &class_device_attr_tx_heartbeat_errors.attr,
-        &class_device_attr_tx_window_errors.attr,
-        &class_device_attr_rx_compressed.attr,
-        &class_device_attr_tx_compressed.attr,
+        &dev_attr_rx_packets.attr,
+        &dev_attr_tx_packets.attr,
+        &dev_attr_rx_bytes.attr,
+        &dev_attr_tx_bytes.attr,
+        &dev_attr_rx_errors.attr,
+        &dev_attr_tx_errors.attr,
+        &dev_attr_rx_dropped.attr,
+        &dev_attr_tx_dropped.attr,
+        &dev_attr_multicast.attr,
+        &dev_attr_collisions.attr,
+        &dev_attr_rx_length_errors.attr,
+        &dev_attr_rx_over_errors.attr,
+        &dev_attr_rx_crc_errors.attr,
+        &dev_attr_rx_frame_errors.attr,
+        &dev_attr_rx_fifo_errors.attr,
+        &dev_attr_rx_missed_errors.attr,
+        &dev_attr_tx_aborted_errors.attr,
+        &dev_attr_tx_carrier_errors.attr,
+        &dev_attr_tx_fifo_errors.attr,
+        &dev_attr_tx_heartbeat_errors.attr,
+        &dev_attr_tx_window_errors.attr,
+        &dev_attr_rx_compressed.attr,
+        &dev_attr_tx_compressed.attr,
         NULL
 };
 
@@ -331,11 +342,11 @@ static struct attribute_group netstat_group = {
 
 #ifdef WIRELESS_EXT
 /* helper function that does all the locking etc for wireless stats */
-static ssize_t wireless_show(struct class_device *cd, char *buf,
+static ssize_t wireless_show(struct device *d, char *buf,
                              ssize_t (*format)(const struct iw_statistics *,
                                                char *))
 {
-        struct net_device *dev = to_net_dev(cd);
+        struct net_device *dev = to_net_dev(d);
         const struct iw_statistics *iw = NULL;
         ssize_t ret = -EINVAL;
         
@@ -358,11 +369,12 @@ static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
 {                                                                       \
         return sprintf(buf, format_string, iw->field);                  \
 }                                                                       \
-static ssize_t show_iw_##name(struct class_device *cd, char *buf)       \
+static ssize_t show_iw_##name(struct device *d,                         \
+                              struct device_attribute *attr, char *buf) \
 {                                                                       \
-        return wireless_show(cd, buf, format_iw_##name);                \
+        return wireless_show(d, buf, format_iw_##name);                 \
 }                                                                       \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
 
 WIRELESS_SHOW(status, status, fmt_hex);
 WIRELESS_SHOW(link, qual.qual, fmt_dec);
@@ -376,16 +388,16 @@ WIRELESS_SHOW(retries, discard.retries, fmt_dec);
 WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
 
 static struct attribute *wireless_attrs[] = {
-        &class_device_attr_status.attr,
-        &class_device_attr_link.attr,
-        &class_device_attr_level.attr,
-        &class_device_attr_noise.attr,
-        &class_device_attr_nwid.attr,
-        &class_device_attr_crypt.attr,
-        &class_device_attr_fragment.attr,
-        &class_device_attr_retries.attr,
-        &class_device_attr_misc.attr,
-        &class_device_attr_beacon.attr,
+        &dev_attr_status.attr,
+        &dev_attr_link.attr,
+        &dev_attr_level.attr,
+        &dev_attr_noise.attr,
+        &dev_attr_nwid.attr,
+        &dev_attr_crypt.attr,
+        &dev_attr_fragment.attr,
+        &dev_attr_retries.attr,
+        &dev_attr_misc.attr,
+        &dev_attr_beacon.attr,
         NULL
 };
 
@@ -396,10 +408,10 @@ static struct attribute_group wireless_group = {
 #endif
 
 #ifdef CONFIG_HOTPLUG
-static int netdev_uevent(struct class_device *cd, char **envp,
+static int netdev_uevent(struct device *d, char **envp,
                          int num_envp, char *buf, int size)
 {
-        struct net_device *dev = to_net_dev(cd);
+        struct net_device *dev = to_net_dev(d);
         int i = 0;
         int n;
 
@@ -419,12 +431,11 @@ static int netdev_uevent(struct class_device *cd, char **envp,
 
 /*
  *      netdev_release -- destroy and free a dead device. 
- *      Called when last reference to class_device kobject is gone.
+ *      Called when last reference to device kobject is gone.
  */
-static void netdev_release(struct class_device *cd)
+static void netdev_release(struct device *d)
 {
-        struct net_device *dev 
-                = container_of(cd, struct net_device, class_dev);
+        struct net_device *dev = to_net_dev(d);
 
         BUG_ON(dev->reg_state != NETREG_RELEASED);
 
@@ -433,31 +444,31 @@ static void netdev_release(struct class_device *cd)
 
 static struct class net_class = {
         .name = "net",
-        .release = netdev_release,
-        .class_dev_attrs = net_class_attributes,
+        .dev_release = netdev_release,
+        .dev_attrs = net_class_attributes,
 #ifdef CONFIG_HOTPLUG
-        .uevent = netdev_uevent,
+        .dev_uevent = netdev_uevent,
 #endif
 };
 
 void netdev_unregister_sysfs(struct net_device * net)
 {
-        class_device_del(&(net->class_dev));
+        device_del(&(net->dev));
 }
 
 /* Create sysfs entries for network device. */
 int netdev_register_sysfs(struct net_device *net)
 {
-        struct class_device *class_dev = &(net->class_dev);
+        struct device *dev = &(net->dev);
         struct attribute_group **groups = net->sysfs_groups;
 
-        class_device_initialize(class_dev);
-        class_dev->class = &net_class;
-        class_dev->class_data = net;
-        class_dev->groups = groups;
+        device_initialize(dev);
+        dev->class = &net_class;
+        dev->platform_data = net;
+        dev->groups = groups;
 
         BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ);
-        strlcpy(class_dev->class_id, net->name, BUS_ID_SIZE);
+        strlcpy(dev->bus_id, net->name, BUS_ID_SIZE);
 
         if (net->get_stats)
                 *groups++ = &netstat_group;
@@ -467,7 +478,7 @@ int netdev_register_sysfs(struct net_device *net)
                 *groups++ = &wireless_group;
 #endif
 
-        return class_device_add(class_dev);
+        return device_add(dev);
 }
 
 int netdev_sysfs_init(void)
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index de7801d589e..f3404ae9f19 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -268,7 +268,7 @@ nodata:
 struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
                 unsigned int length, gfp_t gfp_mask)
 {
-        int node = dev->class_dev.dev ? dev_to_node(dev->class_dev.dev) : -1;
+        int node = dev->dev.parent ? dev_to_node(dev->dev.parent) : -1;
         struct sk_buff *skb;
 
         skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask, 0, node);