Network: convert network devices to use struct device instead of class_device
Greg Kroah-Hartman [Tue, 9 Apr 2002 19:14:34 +0000 (12:14 -0700)]
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>

20 files changed:
drivers/infiniband/ulp/ipoib/ipoib_main.c
drivers/infiniband/ulp/ipoib/ipoib_vlan.c
drivers/net/arm/at91_ether.c
drivers/net/arm/etherh.c
drivers/net/bonding/bond_sysfs.c
drivers/net/iseries_veth.c
drivers/net/macb.c
drivers/net/smc911x.c
drivers/net/smc91x.c
drivers/net/wireless/hostap/hostap_main.c
drivers/net/wireless/orinoco.c
drivers/net/wireless/orinoco_cs.c
drivers/net/wireless/spectrum_cs.c
include/linux/netdevice.h
net/bridge/br_if.c
net/bridge/br_sysfs_br.c
net/bridge/br_sysfs_if.c
net/core/dev.c
net/core/net-sysfs.c
net/core/skbuff.c

index 705eb1d..af5ee2e 100644 (file)
@@ -958,16 +958,17 @@ struct ipoib_dev_priv *ipoib_intf_alloc(const char *name)
        return netdev_priv(dev);
 }
 
-static ssize_t show_pkey(struct class_device *cdev, char *buf)
+static ssize_t show_pkey(struct device *dev,
+                        struct device_attribute *attr, char *buf)
 {
-       struct ipoib_dev_priv *priv =
-               netdev_priv(container_of(cdev, struct net_device, class_dev));
+       struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));
 
        return sprintf(buf, "0x%04x\n", priv->pkey);
 }
-static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
+static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
 
-static ssize_t create_child(struct class_device *cdev,
+static ssize_t create_child(struct device *dev,
+                           struct device_attribute *attr,
                            const char *buf, size_t count)
 {
        int pkey;
@@ -985,14 +986,14 @@ static ssize_t create_child(struct class_device *cdev,
         */
        pkey |= 0x8000;
 
-       ret = ipoib_vlan_add(container_of(cdev, struct net_device, class_dev),
-                            pkey);
+       ret = ipoib_vlan_add(to_net_dev(dev), pkey);
 
        return ret ? ret : count;
 }
-static CLASS_DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child);
+static DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child);
 
-static ssize_t delete_child(struct class_device *cdev,
+static ssize_t delete_child(struct device *dev,
+                           struct device_attribute *attr,
                            const char *buf, size_t count)
 {
        int pkey;
@@ -1004,18 +1005,16 @@ static ssize_t delete_child(struct class_device *cdev,
        if (pkey < 0 || pkey > 0xffff)
                return -EINVAL;
 
-       ret = ipoib_vlan_delete(container_of(cdev, struct net_device, class_dev),
-                               pkey);
+       ret = ipoib_vlan_delete(to_net_dev(dev), pkey);
 
        return ret ? ret : count;
 
 }
-static CLASS_DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child);
+static DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child);
 
 int ipoib_add_pkey_attr(struct net_device *dev)
 {
-       return class_device_create_file(&dev->class_dev,
-                                       &class_device_attr_pkey);
+       return device_create_file(&dev->dev, &dev_attr_pkey);
 }
 
 static struct net_device *ipoib_add_port(const char *format,
@@ -1083,11 +1082,9 @@ static struct net_device *ipoib_add_port(const char *format,
 
        if (ipoib_add_pkey_attr(priv->dev))
                goto sysfs_failed;
-       if (class_device_create_file(&priv->dev->class_dev,
-                                    &class_device_attr_create_child))
+       if (device_create_file(&priv->dev->dev, &dev_attr_create_child))
                goto sysfs_failed;
-       if (class_device_create_file(&priv->dev->class_dev,
-                                    &class_device_attr_delete_child))
+       if (device_create_file(&priv->dev->dev, &dev_attr_delete_child))
                goto sysfs_failed;
 
        return priv->dev;
index f887780..085eafe 100644 (file)
 
 #include "ipoib.h"
 
-static ssize_t show_parent(struct class_device *class_dev, char *buf)
+static ssize_t show_parent(struct device *d, struct device_attribute *attr,
+                          char *buf)
 {
-       struct net_device *dev =
-               container_of(class_dev, struct net_device, class_dev);
+       struct net_device *dev = to_net_dev(d);
        struct ipoib_dev_priv *priv = netdev_priv(dev);
 
        return sprintf(buf, "%s\n", priv->parent->name);
 }
-static CLASS_DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL);
+static DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL);
 
 int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 {
@@ -118,8 +118,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
        if (ipoib_add_pkey_attr(priv->dev))
                goto sysfs_failed;
 
-       if (class_device_create_file(&priv->dev->class_dev,
-                                    &class_device_attr_parent))
+       if (device_create_file(&priv->dev->dev, &dev_attr_parent))
                goto sysfs_failed;
 
        list_add_tail(&priv->list, &ppriv->child_intfs);
index fada15d..1621b8f 100644 (file)
@@ -641,7 +641,7 @@ static void at91ether_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo
 {
        strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-       strlcpy(info->bus_info, dev->class_dev.dev->bus_id, sizeof(info->bus_info));
+       strlcpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
 }
 
 static const struct ethtool_ops at91ether_ethtool_ops = {
index f3faa4f..72c41f5 100644 (file)
@@ -587,7 +587,7 @@ static void etherh_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *i
 {
        strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-       strlcpy(info->bus_info, dev->class_dev.dev->bus_id,
+       strlcpy(info->bus_info, dev->dev.parent->bus_id,
                sizeof(info->bus_info));
 }
 
index ced9ed8..0e610aa 100644 (file)
@@ -39,8 +39,7 @@
 
 /* #define BONDING_DEBUG 1 */
 #include "bonding.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_bond(cd)    ((struct bonding *)(to_net_dev(cd)->priv))
 
 /*---------------------------- Declarations -------------------------------*/
@@ -154,7 +153,7 @@ static ssize_t bonding_store_bonds(struct class *cls, const char *buffer, size_t
                                 * If it's > expected, then there's a file open,
                                 * and we have to fail.
                                 */
-                               if (atomic_read(&bond->dev->class_dev.kobj.kref.refcount)
+                               if (atomic_read(&bond->dev->dev.kobj.kref.refcount)
                                                        > expected_refcount){
                                        rtnl_unlock();
                                        printk(KERN_INFO DRV_NAME
@@ -201,13 +200,13 @@ int bond_create_slave_symlinks(struct net_device *master, struct net_device *sla
        int ret = 0;
 
        /* first, create a link from the slave back to the master */
-       ret = sysfs_create_link(&(slave->class_dev.kobj), &(master->class_dev.kobj),
+       ret = sysfs_create_link(&(slave->dev.kobj), &(master->dev.kobj),
                                "master");
        if (ret)
                return ret;
        /* next, create a link from the master to the slave */
        sprintf(linkname,"slave_%s",slave->name);
-       ret = sysfs_create_link(&(master->class_dev.kobj), &(slave->class_dev.kobj),
+       ret = sysfs_create_link(&(master->dev.kobj), &(slave->dev.kobj),
                                linkname);
        return ret;
 
@@ -217,20 +216,21 @@ void bond_destroy_slave_symlinks(struct net_device *master, struct net_device *s
 {
        char linkname[IFNAMSIZ+7];
 
-       sysfs_remove_link(&(slave->class_dev.kobj), "master");
+       sysfs_remove_link(&(slave->dev.kobj), "master");
        sprintf(linkname,"slave_%s",slave->name);
-       sysfs_remove_link(&(master->class_dev.kobj), linkname);
+       sysfs_remove_link(&(master->dev.kobj), linkname);
 }
 
 
 /*
  * Show the slaves in the current bond.
  */
-static ssize_t bonding_show_slaves(struct class_device *cd, char *buf)
+static ssize_t bonding_show_slaves(struct device *d,
+                                  struct device_attribute *attr, char *buf)
 {
        struct slave *slave;
        int i, res = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        read_lock_bh(&bond->lock);
        bond_for_each_slave(bond, slave, i) {
@@ -254,14 +254,16 @@ static ssize_t bonding_show_slaves(struct class_device *cd, char *buf)
  * up for this to succeed.
  * This function is largely the same flow as bonding_update_bonds().
  */
-static ssize_t bonding_store_slaves(struct class_device *cd, const char *buffer, size_t count)
+static ssize_t bonding_store_slaves(struct device *d,
+                                   struct device_attribute *attr,
+                                   const char *buffer, size_t count)
 {
        char command[IFNAMSIZ + 1] = { 0, };
        char *ifname;
        int i, res, found, ret = count;
        struct slave *slave;
        struct net_device *dev = NULL;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        /* Quick sanity check -- is the bond interface up? */
        if (!(bond->dev->flags & IFF_UP)) {
@@ -387,25 +389,28 @@ out:
        return ret;
 }
 
-static CLASS_DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, bonding_store_slaves);
+static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, bonding_store_slaves);
 
 /*
  * Show and set the bonding mode.  The bond interface must be down to
  * change the mode.
  */
-static ssize_t bonding_show_mode(struct class_device *cd, char *buf)
+static ssize_t bonding_show_mode(struct device *d,
+                                struct device_attribute *attr, char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%s %d\n",
                        bond_mode_tbl[bond->params.mode].modename,
                        bond->params.mode) + 1;
 }
 
-static ssize_t bonding_store_mode(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_mode(struct device *d,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->dev->flags & IFF_UP) {
                printk(KERN_ERR DRV_NAME
@@ -438,16 +443,18 @@ static ssize_t bonding_store_mode(struct class_device *cd, const char *buf, size
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, bonding_show_mode, bonding_store_mode);
+static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, bonding_show_mode, bonding_store_mode);
 
 /*
  * Show and set the bonding transmit hash method.  The bond interface must be down to
  * change the xmit hash policy.
  */
-static ssize_t bonding_show_xmit_hash(struct class_device *cd, char *buf)
+static ssize_t bonding_show_xmit_hash(struct device *d,
+                                     struct device_attribute *attr,
+                                     char *buf)
 {
        int count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if ((bond->params.mode != BOND_MODE_XOR) &&
            (bond->params.mode != BOND_MODE_8023AD)) {
@@ -462,10 +469,12 @@ static ssize_t bonding_show_xmit_hash(struct class_device *cd, char *buf)
        return count;
 }
 
-static ssize_t bonding_store_xmit_hash(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_xmit_hash(struct device *d,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->dev->flags & IFF_UP) {
                printk(KERN_ERR DRV_NAME
@@ -501,24 +510,28 @@ static ssize_t bonding_store_xmit_hash(struct class_device *cd, const char *buf,
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, bonding_show_xmit_hash, bonding_store_xmit_hash);
+static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, bonding_show_xmit_hash, bonding_store_xmit_hash);
 
 /*
  * Show and set arp_validate.
  */
-static ssize_t bonding_show_arp_validate(struct class_device *cd, char *buf)
+static ssize_t bonding_show_arp_validate(struct device *d,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%s %d\n",
                       arp_validate_tbl[bond->params.arp_validate].modename,
                       bond->params.arp_validate) + 1;
 }
 
-static ssize_t bonding_store_arp_validate(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_arp_validate(struct device *d,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t count)
 {
        int new_value;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        new_value = bond_parse_parm((char *)buf, arp_validate_tbl);
        if (new_value < 0) {
@@ -548,7 +561,7 @@ static ssize_t bonding_store_arp_validate(struct class_device *cd, const char *b
        return count;
 }
 
-static CLASS_DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, bonding_store_arp_validate);
+static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, bonding_store_arp_validate);
 
 /*
  * Show and set the arp timer interval.  There are two tricky bits
@@ -556,17 +569,21 @@ static CLASS_DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_valid
  * MII monitoring.  Second, if the ARP timer isn't running, we must
  * start it.
  */
-static ssize_t bonding_show_arp_interval(struct class_device *cd, char *buf)
+static ssize_t bonding_show_arp_interval(struct device *d,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%d\n", bond->params.arp_interval) + 1;
 }
 
-static ssize_t bonding_store_arp_interval(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_arp_interval(struct device *d,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (sscanf(buf, "%d", &new_value) != 1) {
                printk(KERN_ERR DRV_NAME
@@ -638,15 +655,17 @@ static ssize_t bonding_store_arp_interval(struct class_device *cd, const char *b
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR , bonding_show_arp_interval, bonding_store_arp_interval);
+static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR , bonding_show_arp_interval, bonding_store_arp_interval);
 
 /*
  * Show and set the arp targets.
  */
-static ssize_t bonding_show_arp_targets(struct class_device *cd, char *buf)
+static ssize_t bonding_show_arp_targets(struct device *d,
+                                       struct device_attribute *attr,
+                                       char *buf)
 {
        int i, res = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
                if (bond->params.arp_targets[i])
@@ -660,11 +679,13 @@ static ssize_t bonding_show_arp_targets(struct class_device *cd, char *buf)
        return res;
 }
 
-static ssize_t bonding_store_arp_targets(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_arp_targets(struct device *d,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
 {
        u32 newtarget;
        int i = 0, done = 0, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
        u32 *targets;
 
        targets = bond->params.arp_targets;
@@ -742,24 +763,28 @@ static ssize_t bonding_store_arp_targets(struct class_device *cd, const char *bu
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
+static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
 
 /*
  * Show and set the up and down delays.  These must be multiples of the
  * MII monitoring value, and are stored internally as the multiplier.
  * Thus, we must translate to MS for the real world.
  */
-static ssize_t bonding_show_downdelay(struct class_device *cd, char *buf)
+static ssize_t bonding_show_downdelay(struct device *d,
+                                     struct device_attribute *attr,
+                                     char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon) + 1;
 }
 
-static ssize_t bonding_store_downdelay(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_downdelay(struct device *d,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (!(bond->params.miimon)) {
                printk(KERN_ERR DRV_NAME
@@ -800,20 +825,24 @@ static ssize_t bonding_store_downdelay(struct class_device *cd, const char *buf,
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR , bonding_show_downdelay, bonding_store_downdelay);
+static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR , bonding_show_downdelay, bonding_store_downdelay);
 
-static ssize_t bonding_show_updelay(struct class_device *cd, char *buf)
+static ssize_t bonding_show_updelay(struct device *d,
+                                   struct device_attribute *attr,
+                                   char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon) + 1;
 
 }
 
-static ssize_t bonding_store_updelay(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_updelay(struct device *d,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (!(bond->params.miimon)) {
                printk(KERN_ERR DRV_NAME
@@ -854,25 +883,29 @@ static ssize_t bonding_store_updelay(struct class_device *cd, const char *buf, s
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR , bonding_show_updelay, bonding_store_updelay);
+static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR , bonding_show_updelay, bonding_store_updelay);
 
 /*
  * Show and set the LACP interval.  Interface must be down, and the mode
  * must be set to 802.3ad mode.
  */
-static ssize_t bonding_show_lacp(struct class_device *cd, char *buf)
+static ssize_t bonding_show_lacp(struct device *d,
+                                struct device_attribute *attr,
+                                char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%s %d\n",
                bond_lacp_tbl[bond->params.lacp_fast].modename,
                bond->params.lacp_fast) + 1;
 }
 
-static ssize_t bonding_store_lacp(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_lacp(struct device *d,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->dev->flags & IFF_UP) {
                printk(KERN_ERR DRV_NAME
@@ -906,7 +939,7 @@ static ssize_t bonding_store_lacp(struct class_device *cd, const char *buf, size
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bonding_store_lacp);
+static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bonding_store_lacp);
 
 /*
  * Show and set the MII monitor interval.  There are two tricky bits
@@ -914,17 +947,21 @@ static CLASS_DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bondin
  * ARP monitoring.  Second, if the timer isn't running, we must
  * start it.
  */
-static ssize_t bonding_show_miimon(struct class_device *cd, char *buf)
+static ssize_t bonding_show_miimon(struct device *d,
+                                  struct device_attribute *attr,
+                                  char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%d\n", bond->params.miimon) + 1;
 }
 
-static ssize_t bonding_store_miimon(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_miimon(struct device *d,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (sscanf(buf, "%d", &new_value) != 1) {
                printk(KERN_ERR DRV_NAME
@@ -1000,7 +1037,7 @@ static ssize_t bonding_store_miimon(struct class_device *cd, const char *buf, si
 out:
        return ret;
 }
-static CLASS_DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding_store_miimon);
+static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding_store_miimon);
 
 /*
  * Show and set the primary slave.  The store function is much
@@ -1009,10 +1046,12 @@ static CLASS_DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding
  * The bond must be a mode that supports a primary for this be
  * set.
  */
-static ssize_t bonding_show_primary(struct class_device *cd, char *buf)
+static ssize_t bonding_show_primary(struct device *d,
+                                   struct device_attribute *attr,
+                                   char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->primary_slave)
                count = sprintf(buf, "%s\n", bond->primary_slave->dev->name) + 1;
@@ -1022,11 +1061,13 @@ static ssize_t bonding_show_primary(struct class_device *cd, char *buf)
        return count;
 }
 
-static ssize_t bonding_store_primary(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_primary(struct device *d,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
        int i;
        struct slave *slave;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        write_lock_bh(&bond->lock);
        if (!USES_PRIMARY(bond->params.mode)) {
@@ -1065,22 +1106,26 @@ out:
        write_unlock_bh(&bond->lock);
        return count;
 }
-static CLASS_DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, bonding_show_primary, bonding_store_primary);
+static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, bonding_show_primary, bonding_store_primary);
 
 /*
  * Show and set the use_carrier flag.
  */
-static ssize_t bonding_show_carrier(struct class_device *cd, char *buf)
+static ssize_t bonding_show_carrier(struct device *d,
+                                   struct device_attribute *attr,
+                                   char *buf)
 {
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        return sprintf(buf, "%d\n", bond->params.use_carrier) + 1;
 }
 
-static ssize_t bonding_store_carrier(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_carrier(struct device *d,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
        int new_value, ret = count;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
 
        if (sscanf(buf, "%d", &new_value) != 1) {
@@ -1102,16 +1147,18 @@ static ssize_t bonding_store_carrier(struct class_device *cd, const char *buf, s
 out:
        return count;
 }
-static CLASS_DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, bonding_show_carrier, bonding_store_carrier);
+static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, bonding_show_carrier, bonding_store_carrier);
 
 
 /*
  * Show and set currently active_slave.
  */
-static ssize_t bonding_show_active_slave(struct class_device *cd, char *buf)
+static ssize_t bonding_show_active_slave(struct device *d,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
        struct slave *curr;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
        int count;
 
 
@@ -1126,13 +1173,15 @@ static ssize_t bonding_show_active_slave(struct class_device *cd, char *buf)
        return count;
 }
 
-static ssize_t bonding_store_active_slave(struct class_device *cd, const char *buf, size_t count)
+static ssize_t bonding_store_active_slave(struct device *d,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t count)
 {
        int i;
        struct slave *slave;
         struct slave *old_active = NULL;
         struct slave *new_active = NULL;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        write_lock_bh(&bond->lock);
        if (!USES_PRIMARY(bond->params.mode)) {
@@ -1194,16 +1243,18 @@ out:
        return count;
 
 }
-static CLASS_DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, bonding_show_active_slave, bonding_store_active_slave);
+static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, bonding_show_active_slave, bonding_store_active_slave);
 
 
 /*
  * Show link status of the bond interface.
  */
-static ssize_t bonding_show_mii_status(struct class_device *cd, char *buf)
+static ssize_t bonding_show_mii_status(struct device *d,
+                                      struct device_attribute *attr,
+                                      char *buf)
 {
        struct slave *curr;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        read_lock(&bond->curr_slave_lock);
        curr = bond->curr_active_slave;
@@ -1211,16 +1262,18 @@ static ssize_t bonding_show_mii_status(struct class_device *cd, char *buf)
 
        return sprintf(buf, "%s\n", (curr) ? "up" : "down") + 1;
 }
-static CLASS_DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
+static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
 
 
 /*
  * Show current 802.3ad aggregator ID.
  */
-static ssize_t bonding_show_ad_aggregator(struct class_device *cd, char *buf)
+static ssize_t bonding_show_ad_aggregator(struct device *d,
+                                         struct device_attribute *attr,
+                                         char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                struct ad_info ad_info;
@@ -1231,16 +1284,18 @@ static ssize_t bonding_show_ad_aggregator(struct class_device *cd, char *buf)
 
        return count;
 }
-static CLASS_DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
+static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
 
 
 /*
  * Show number of active 802.3ad ports.
  */
-static ssize_t bonding_show_ad_num_ports(struct class_device *cd, char *buf)
+static ssize_t bonding_show_ad_num_ports(struct device *d,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                struct ad_info ad_info;
@@ -1251,16 +1306,18 @@ static ssize_t bonding_show_ad_num_ports(struct class_device *cd, char *buf)
 
        return count;
 }
-static CLASS_DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
+static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
 
 
 /*
  * Show current 802.3ad actor key.
  */
-static ssize_t bonding_show_ad_actor_key(struct class_device *cd, char *buf)
+static ssize_t bonding_show_ad_actor_key(struct device *d,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                struct ad_info ad_info;
@@ -1271,16 +1328,18 @@ static ssize_t bonding_show_ad_actor_key(struct class_device *cd, char *buf)
 
        return count;
 }
-static CLASS_DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
+static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
 
 
 /*
  * Show current 802.3ad partner key.
  */
-static ssize_t bonding_show_ad_partner_key(struct class_device *cd, char *buf)
+static ssize_t bonding_show_ad_partner_key(struct device *d,
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                struct ad_info ad_info;
@@ -1291,16 +1350,18 @@ static ssize_t bonding_show_ad_partner_key(struct class_device *cd, char *buf)
 
        return count;
 }
-static CLASS_DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
+static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
 
 
 /*
  * Show current 802.3ad partner mac.
  */
-static ssize_t bonding_show_ad_partner_mac(struct class_device *cd, char *buf)
+static ssize_t bonding_show_ad_partner_mac(struct device *d,
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
        int count = 0;
-       struct bonding *bond = to_bond(cd);
+       struct bonding *bond = to_bond(d);
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                struct ad_info ad_info;
@@ -1319,30 +1380,30 @@ static ssize_t bonding_show_ad_partner_mac(struct class_device *cd, char *buf)
 
        return count;
 }
-static CLASS_DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
+static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
 
 
 
 static struct attribute *per_bond_attrs[] = {
-       &class_device_attr_slaves.attr,
-       &class_device_attr_mode.attr,
-       &class_device_attr_arp_validate.attr,
-       &class_device_attr_arp_interval.attr,
-       &class_device_attr_arp_ip_target.attr,
-       &class_device_attr_downdelay.attr,
-       &class_device_attr_updelay.attr,
-       &class_device_attr_lacp_rate.attr,
-       &class_device_attr_xmit_hash_policy.attr,
-       &class_device_attr_miimon.attr,
-       &class_device_attr_primary.attr,
-       &class_device_attr_use_carrier.attr,
-       &class_device_attr_active_slave.attr,
-       &class_device_attr_mii_status.attr,
-       &class_device_attr_ad_aggregator.attr,
-       &class_device_attr_ad_num_ports.attr,
-       &class_device_attr_ad_actor_key.attr,
-       &class_device_attr_ad_partner_key.attr,
-       &class_device_attr_ad_partner_mac.attr,
+       &dev_attr_slaves.attr,
+       &dev_attr_mode.attr,
+       &dev_attr_arp_validate.attr,
+       &dev_attr_arp_interval.attr,
+       &dev_attr_arp_ip_target.attr,
+       &dev_attr_downdelay.attr,
+       &dev_attr_updelay.attr,
+       &dev_attr_lacp_rate.attr,
+       &dev_attr_xmit_hash_policy.attr,
+       &dev_attr_miimon.attr,
+       &dev_attr_primary.attr,
+       &dev_attr_use_carrier.attr,
+       &dev_attr_active_slave.attr,
+       &dev_attr_mii_status.attr,
+       &dev_attr_ad_aggregator.attr,
+       &dev_attr_ad_num_ports.attr,
+       &dev_attr_ad_actor_key.attr,
+       &dev_attr_ad_partner_key.attr,
+       &dev_attr_ad_partner_mac.attr,
        NULL,
 };
 
@@ -1367,7 +1428,7 @@ int bond_create_sysfs(void)
        if (!firstbond)
                return -ENODEV;
 
-       netdev_class = firstbond->dev->class_dev.class;
+       netdev_class = firstbond->dev->dev.class;
        if (!netdev_class)
                return -ENODEV;
 
@@ -1395,13 +1456,13 @@ int bond_create_sysfs_entry(struct bonding *bond)
        struct net_device *dev = bond->dev;
        int err;
 
-       err = sysfs_create_group(&(dev->class_dev.kobj), &bonding_group);
+       err = sysfs_create_group(&(dev->dev.kobj), &bonding_group);
        if (err) {
                printk(KERN_EMERG "eek! didn't create group!\n");
        }
 
        if (expected_refcount < 1)
-               expected_refcount = atomic_read(&bond->dev->class_dev.kobj.kref.refcount);
+               expected_refcount = atomic_read(&bond->dev->dev.kobj.kref.refcount);
 
        return err;
 }
@@ -1412,6 +1473,6 @@ void bond_destroy_sysfs_entry(struct bonding *bond)
 {
        struct net_device *dev = bond->dev;
 
-       sysfs_remove_group(&(dev->class_dev.kobj), &bonding_group);
+       sysfs_remove_group(&(dev->dev.kobj), &bonding_group);
 }
 
index 2194b56..0e9ba3c 100644 (file)
@@ -1102,7 +1102,7 @@ static struct net_device * __init veth_probe_one(int vlan,
        }
 
        kobject_init(&port->kobject);
-       port->kobject.parent = &dev->class_dev.kobj;
+       port->kobject.parent = &dev->dev.kobj;
        port->kobject.ktype  = &veth_port_ktype;
        kobject_set_name(&port->kobject, "veth_port");
        if (0 != kobject_add(&port->kobject))
index 25b559b..2af2045 100644 (file)
@@ -27,8 +27,6 @@
 
 #include "macb.h"
 
-#define to_net_dev(class) container_of(class, struct net_device, class_dev)
-
 #define RX_BUFFER_SIZE         128
 #define RX_RING_SIZE           512
 #define RX_RING_BYTES          (sizeof(struct dma_desc) * RX_RING_SIZE)
@@ -945,10 +943,10 @@ static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
        return ret;
 }
 
-static ssize_t macb_mii_show(const struct class_device *cd, char *buf,
+static ssize_t macb_mii_show(const struct device *_dev, char *buf,
                        unsigned long addr)
 {
-       struct net_device *dev = to_net_dev(cd);
+       struct net_device *dev = to_net_dev(_dev);
        struct macb *bp = netdev_priv(dev);
        ssize_t ret = -EINVAL;
 
@@ -962,11 +960,13 @@ static ssize_t macb_mii_show(const struct class_device *cd, char *buf,
 }
 
 #define MII_ENTRY(name, addr)                                  \
-static ssize_t show_##name(struct class_device *cd, char *buf) \
+static ssize_t show_##name(struct device *_dev,                        \
+                          struct device_attribute *attr,       \
+                          char *buf)                           \
 {                                                              \
-       return macb_mii_show(cd, buf, addr);                    \
+       return macb_mii_show(_dev, buf, addr);                  \
 }                                                              \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
 
 MII_ENTRY(bmcr, MII_BMCR);
 MII_ENTRY(bmsr, MII_BMSR);
@@ -977,13 +977,13 @@ MII_ENTRY(lpa, MII_LPA);
 MII_ENTRY(expansion, MII_EXPANSION);
 
 static struct attribute *macb_mii_attrs[] = {
-       &class_device_attr_bmcr.attr,
-       &class_device_attr_bmsr.attr,
-       &class_device_attr_physid1.attr,
-       &class_device_attr_physid2.attr,
-       &class_device_attr_advertise.attr,
-       &class_device_attr_lpa.attr,
-       &class_device_attr_expansion.attr,
+       &dev_attr_bmcr.attr,
+       &dev_attr_bmsr.attr,
+       &dev_attr_physid1.attr,
+       &dev_attr_physid2.attr,
+       &dev_attr_advertise.attr,
+       &dev_attr_lpa.attr,
+       &dev_attr_expansion.attr,
        NULL,
 };
 
@@ -994,17 +994,17 @@ static struct attribute_group macb_mii_group = {
 
 static void macb_unregister_sysfs(struct net_device *net)
 {
-       struct class_device *class_dev = &net->class_dev;
+       struct device *_dev = &net->dev;
 
-       sysfs_remove_group(&class_dev->kobj, &macb_mii_group);
+       sysfs_remove_group(&_dev->kobj, &macb_mii_group);
 }
 
 static int macb_register_sysfs(struct net_device *net)
 {
-       struct class_device *class_dev = &net->class_dev;
+       struct device *_dev = &net->dev;
        int ret;
 
-       ret = sysfs_create_group(&class_dev->kobj, &macb_mii_group);
+       ret = sysfs_create_group(&_dev->kobj, &macb_mii_group);
        if (ret)
                printk(KERN_WARNING
                       "%s: sysfs mii attribute registration failed: %d\n",
index 43af614..c956141 100644 (file)
@@ -1659,7 +1659,7 @@ smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        strncpy(info->driver, CARDNAME, sizeof(info->driver));
        strncpy(info->version, version, sizeof(info->version));
-       strncpy(info->bus_info, dev->class_dev.dev->bus_id, sizeof(info->bus_info));
+       strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
 }
 
 static int smc911x_ethtool_nwayreset(struct net_device *dev)
index e62a958..49f4b77 100644 (file)
@@ -1712,7 +1712,7 @@ smc_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        strncpy(info->driver, CARDNAME, sizeof(info->driver));
        strncpy(info->version, version, sizeof(info->version));
-       strncpy(info->bus_info, dev->class_dev.dev->bus_id, sizeof(info->bus_info));
+       strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
 }
 
 static int smc_ethtool_nwayreset(struct net_device *dev)
index 04c19ce..9077e6e 100644 (file)
@@ -84,7 +84,7 @@ struct net_device * hostap_add_interface(struct local_info *local,
        if (strchr(dev->name, '%'))
                ret = dev_alloc_name(dev, dev->name);
 
-       SET_NETDEV_DEV(dev, mdev->class_dev.dev);
+       SET_NETDEV_DEV(dev, mdev->dev.parent);
        if (ret >= 0)
                ret = register_netdevice(dev);
 
index 936c888..656f216 100644 (file)
@@ -4293,8 +4293,8 @@ static void orinoco_get_drvinfo(struct net_device *dev,
        strncpy(info->driver, DRIVER_NAME, sizeof(info->driver) - 1);
        strncpy(info->version, DRIVER_VERSION, sizeof(info->version) - 1);
        strncpy(info->fw_version, priv->fw_name, sizeof(info->fw_version) - 1);
-       if (dev->class_dev.dev)
-               strncpy(info->bus_info, dev->class_dev.dev->bus_id,
+       if (dev->dev.parent)
+               strncpy(info->bus_info, dev->dev.parent->bus_id,
                        sizeof(info->bus_info) - 1);
        else
                snprintf(info->bus_info, sizeof(info->bus_info) - 1,
index d08ae8d..d1e5022 100644 (file)
@@ -332,7 +332,7 @@ orinoco_cs_config(struct pcmcia_device *link)
 
        /* Finally, report what we've done */
        printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "
-              "0x%04x-0x%04x\n", dev->name, dev->class_dev.dev->bus_id,
+              "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id,
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
 
index cf2d148..af70460 100644 (file)
@@ -806,7 +806,7 @@ spectrum_cs_config(struct pcmcia_device *link)
 
        /* Finally, report what we've done */
        printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "
-              "0x%04x-0x%04x\n", dev->name, dev->class_dev.dev->bus_id,
+              "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id,
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
 
index fea0d9d..2e37f50 100644 (file)
@@ -529,10 +529,11 @@ struct net_device
        struct net_bridge_port  *br_port;
 
        /* class/net/name entry */
-       struct class_device     class_dev;
+       struct device           dev;
        /* space for optional statistics and wireless sysfs groups */
        struct attribute_group  *sysfs_groups[3];
 };
+#define to_net_dev(d) container_of(d, struct net_device, dev)
 
 #define        NETDEV_ALIGN            32
 #define        NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)
@@ -548,7 +549,7 @@ static inline void *netdev_priv(struct net_device *dev)
 /* Set the sysfs physical device reference for the network logical device
  * if set prior to registration will cause a symlink during initialization.
  */
-#define SET_NETDEV_DEV(net, pdev)      ((net)->class_dev.dev = (pdev))
+#define SET_NETDEV_DEV(net, pdev)      ((net)->dev.parent = (pdev))
 
 struct packet_type {
        __be16                  type;   /* This is really htons(ether_type). */
index 55bb263..2b7c2c7 100644 (file)
@@ -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;
index de9d1a9..ce10464 100644 (file)
 
 #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);
index c51c9e4..0bc2aef 100644 (file)
@@ -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;
index e660cb5..455d589 100644 (file)
@@ -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
index f47f319..44db095 100644 (file)
@@ -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)
index de7801d..f3404ae 100644 (file)
@@ -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);