4 files changed, 143 insertions, 131 deletions

diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 981fed397d1d..707c3134ddf2 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -60,12 +60,19 @@ 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 device *dev,                         \
+static ssize_t field##_show(struct device *dev,                         \
                             struct device_attribute *attr, char *buf)   \
 {                                                                       \
         return netdev_show(dev, attr, buf, format_##field);             \
-}
+}                                                                       \
+
+#define NETDEVICE_SHOW_RO(field, format_string)                         \
+NETDEVICE_SHOW(field, format_string);                                   \
+static DEVICE_ATTR_RO(field)
 
+#define NETDEVICE_SHOW_RW(field, format_string)                         \
+NETDEVICE_SHOW(field, format_string);                                   \
+static DEVICE_ATTR_RW(field)
 
 /* use same locking and permission rules as SIF* ioctl's */
 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
@@ -96,16 +103,16 @@ static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
         return ret;
 }
 
-NETDEVICE_SHOW(dev_id, fmt_hex);
-NETDEVICE_SHOW(addr_assign_type, fmt_dec);
-NETDEVICE_SHOW(addr_len, fmt_dec);
-NETDEVICE_SHOW(iflink, fmt_dec);
-NETDEVICE_SHOW(ifindex, fmt_dec);
-NETDEVICE_SHOW(type, fmt_dec);
-NETDEVICE_SHOW(link_mode, fmt_dec);
+NETDEVICE_SHOW_RO(dev_id, fmt_hex);
+NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
+NETDEVICE_SHOW_RO(addr_len, fmt_dec);
+NETDEVICE_SHOW_RO(iflink, fmt_dec);
+NETDEVICE_SHOW_RO(ifindex, fmt_dec);
+NETDEVICE_SHOW_RO(type, fmt_dec);
+NETDEVICE_SHOW_RO(link_mode, fmt_dec);
 
 /* use same locking rules as GIFHWADDR ioctl's */
-static ssize_t show_address(struct device *dev, struct device_attribute *attr,
+static ssize_t address_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
 {
         struct net_device *net = to_net_dev(dev);
@@ -117,15 +124,17 @@ static ssize_t show_address(struct device *dev, struct device_attribute *attr,
         read_unlock(&dev_base_lock);
         return ret;
 }
+static DEVICE_ATTR_RO(address);
 
-static ssize_t show_broadcast(struct device *dev,
-                            struct device_attribute *attr, char *buf)
+static ssize_t broadcast_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
         struct net_device *net = to_net_dev(dev);
         if (dev_isalive(net))
                 return sysfs_format_mac(buf, net->broadcast, net->addr_len);
         return -EINVAL;
 }
+static DEVICE_ATTR_RO(broadcast);
 
 static int change_carrier(struct net_device *net, unsigned long new_carrier)
 {
@@ -134,13 +143,13 @@ static int change_carrier(struct net_device *net, unsigned long new_carrier)
         return dev_change_carrier(net, (bool) new_carrier);
 }
 
-static ssize_t store_carrier(struct device *dev, struct device_attribute *attr,
-                         const char *buf, size_t len)
+static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t len)
 {
         return netdev_store(dev, attr, buf, len, change_carrier);
 }
 
-static ssize_t show_carrier(struct device *dev,
+static ssize_t carrier_show(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
@@ -149,8 +158,9 @@ static ssize_t show_carrier(struct device *dev,
         }
         return -EINVAL;
 }
+static DEVICE_ATTR_RW(carrier);
 
-static ssize_t show_speed(struct device *dev,
+static ssize_t speed_show(struct device *dev,
                           struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
@@ -167,8 +177,9 @@ static ssize_t show_speed(struct device *dev,
         rtnl_unlock();
         return ret;
 }
+static DEVICE_ATTR_RO(speed);
 
-static ssize_t show_duplex(struct device *dev,
+static ssize_t duplex_show(struct device *dev,
                            struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
@@ -198,8 +209,9 @@ static ssize_t show_duplex(struct device *dev,
         rtnl_unlock();
         return ret;
 }
+static DEVICE_ATTR_RO(duplex);
 
-static ssize_t show_dormant(struct device *dev,
+static ssize_t dormant_show(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         struct net_device *netdev = to_net_dev(dev);
@@ -209,6 +221,7 @@ static ssize_t show_dormant(struct device *dev,
 
         return -EINVAL;
 }
+static DEVICE_ATTR_RO(dormant);
 
 static const char *const operstates[] = {
         "unknown",
@@ -220,7 +233,7 @@ static const char *const operstates[] = {
         "up"
 };
 
-static ssize_t show_operstate(struct device *dev,
+static ssize_t operstate_show(struct device *dev,
                               struct device_attribute *attr, char *buf)
 {
         const struct net_device *netdev = to_net_dev(dev);
@@ -237,35 +250,33 @@ static ssize_t show_operstate(struct device *dev,
 
         return sprintf(buf, "%s\n", operstates[operstate]);
 }
+static DEVICE_ATTR_RO(operstate);
 
 /* read-write attributes */
-NETDEVICE_SHOW(mtu, fmt_dec);
 
 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 device *dev, struct device_attribute *attr,
+static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
                          const char *buf, size_t len)
 {
         return netdev_store(dev, attr, buf, len, change_mtu);
 }
-
-NETDEVICE_SHOW(flags, fmt_hex);
+NETDEVICE_SHOW_RW(mtu, fmt_dec);
 
 static int change_flags(struct net_device *net, unsigned long new_flags)
 {
         return dev_change_flags(net, (unsigned int) new_flags);
 }
 
-static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
+static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
                            const char *buf, size_t len)
 {
         return netdev_store(dev, attr, buf, len, change_flags);
 }
-
-NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
+NETDEVICE_SHOW_RW(flags, fmt_hex);
 
 static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
 {
@@ -273,7 +284,7 @@ static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
         return 0;
 }
 
-static ssize_t store_tx_queue_len(struct device *dev,
+static ssize_t tx_queue_len_store(struct device *dev,
                                   struct device_attribute *attr,
                                   const char *buf, size_t len)
 {
@@ -282,8 +293,9 @@ static ssize_t store_tx_queue_len(struct device *dev,
 
         return netdev_store(dev, attr, buf, len, change_tx_queue_len);
 }
+NETDEVICE_SHOW_RW(tx_queue_len, fmt_ulong);
 
-static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
+static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
                              const char *buf, size_t len)
 {
         struct net_device *netdev = to_net_dev(dev);
@@ -306,7 +318,7 @@ static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
         return ret < 0 ? ret : len;
 }
 
-static ssize_t show_ifalias(struct device *dev,
+static ssize_t ifalias_show(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         const struct net_device *netdev = to_net_dev(dev);
@@ -319,8 +331,7 @@ static ssize_t show_ifalias(struct device *dev,
         rtnl_unlock();
         return ret;
 }
-
-NETDEVICE_SHOW(group, fmt_dec);
+static DEVICE_ATTR_RW(ifalias);
 
 static int change_group(struct net_device *net, unsigned long new_group)
 {
@@ -328,35 +339,37 @@ static int change_group(struct net_device *net, unsigned long new_group)
         return 0;
 }
 
-static ssize_t store_group(struct device *dev, struct device_attribute *attr,
-                         const char *buf, size_t len)
+static ssize_t group_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t len)
 {
         return netdev_store(dev, attr, buf, len, change_group);
 }
-
-static struct device_attribute net_class_attributes[] = {
-        __ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL),
-        __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
-        __ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
-        __ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
-        __ATTR(iflink, S_IRUGO, show_iflink, NULL),
-        __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
-        __ATTR(type, S_IRUGO, show_type, NULL),
-        __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
-        __ATTR(address, S_IRUGO, show_address, NULL),
-        __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
-        __ATTR(carrier, S_IRUGO | S_IWUSR, show_carrier, store_carrier),
-        __ATTR(speed, S_IRUGO, show_speed, NULL),
-        __ATTR(duplex, S_IRUGO, show_duplex, NULL),
-        __ATTR(dormant, S_IRUGO, show_dormant, NULL),
-        __ATTR(operstate, S_IRUGO, show_operstate, NULL),
-        __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
-        __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
-        __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
-               store_tx_queue_len),
-        __ATTR(netdev_group, S_IRUGO | S_IWUSR, show_group, store_group),
-        {}
+NETDEVICE_SHOW(group, fmt_dec);
+static DEVICE_ATTR(netdev_group, S_IRUGO | S_IWUSR, group_show, group_store);
+
+static struct attribute *net_class_attrs[] = {
+        &dev_attr_netdev_group.attr,
+        &dev_attr_type.attr,
+        &dev_attr_dev_id.attr,
+        &dev_attr_iflink.attr,
+        &dev_attr_ifindex.attr,
+        &dev_attr_addr_assign_type.attr,
+        &dev_attr_addr_len.attr,
+        &dev_attr_link_mode.attr,
+        &dev_attr_address.attr,
+        &dev_attr_broadcast.attr,
+        &dev_attr_speed.attr,
+        &dev_attr_duplex.attr,
+        &dev_attr_dormant.attr,
+        &dev_attr_operstate.attr,
+        &dev_attr_ifalias.attr,
+        &dev_attr_carrier.attr,
+        &dev_attr_mtu.attr,
+        &dev_attr_flags.attr,
+        &dev_attr_tx_queue_len.attr,
+        NULL,
 };
+ATTRIBUTE_GROUPS(net_class);
 
 /* Show a given an attribute in the statistics group */
 static ssize_t netstat_show(const struct device *d,
@@ -382,13 +395,13 @@ static ssize_t netstat_show(const struct device *d,
 
 /* generate a read-only statistics attribute */
 #define NETSTAT_ENTRY(name)                                             \
-static ssize_t show_##name(struct device *d,                            \
+static ssize_t name##_show(struct device *d,                            \
                            struct device_attribute *attr, char *buf)    \
 {                                                                       \
         return netstat_show(d, attr, buf,                               \
                             offsetof(struct rtnl_link_stats64, name));  \
 }                                                                       \
-static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
+static DEVICE_ATTR_RO(name)
 
 NETSTAT_ENTRY(rx_packets);
 NETSTAT_ENTRY(tx_packets);
@@ -457,6 +470,9 @@ static struct attribute_group wireless_group = {
         .attrs = wireless_attrs,
 };
 #endif
+
+#else /* CONFIG_SYSFS */
+#define net_class_groups        NULL
 #endif /* CONFIG_SYSFS */
 
 #ifdef CONFIG_RPS
@@ -1229,9 +1245,7 @@ static const void *net_namespace(struct device *d)
 static struct class net_class = {
         .name = "net",
         .dev_release = netdev_release,
-#ifdef CONFIG_SYSFS
-        .dev_attrs = net_class_attributes,
-#endif /* CONFIG_SYSFS */
+        .dev_groups = net_class_groups,
         .dev_uevent = netdev_uevent,
         .ns_type = &net_ns_type_operations,
         .namespace = net_namespace,
diff --git a/net/ieee802154/wpan-class.c b/net/ieee802154/wpan-class.c
index 13571eae6bae..ef56ab5b35fe 100644
--- a/net/ieee802154/wpan-class.c
+++ b/net/ieee802154/wpan-class.c
@@ -36,7 +36,8 @@ static ssize_t name ## _show(struct device *dev,			\
         ret = snprintf(buf, PAGE_SIZE, format_string "\n", args);       \
         mutex_unlock(&phy->pib_lock);                                   \
         return ret;                                                     \
-}
+}                                                                       \
+static DEVICE_ATTR_RO(name);
 
 #define MASTER_SHOW(field, format_string)                               \
         MASTER_SHOW_COMPLEX(field, format_string, phy->field)
@@ -66,15 +67,17 @@ static ssize_t channels_supported_show(struct device *dev,
         mutex_unlock(&phy->pib_lock);
         return len;
 }
-
-static struct device_attribute pmib_attrs[] = {
-        __ATTR_RO(current_channel),
-        __ATTR_RO(current_page),
-        __ATTR_RO(channels_supported),
-        __ATTR_RO(transmit_power),
-        __ATTR_RO(cca_mode),
-        {},
+static DEVICE_ATTR_RO(channels_supported);
+
+static struct attribute *pmib_attrs[] = {
+        &dev_attr_current_channel.attr,
+        &dev_attr_current_page.attr,
+        &dev_attr_channels_supported.attr,
+        &dev_attr_transmit_power.attr,
+        &dev_attr_cca_mode.attr,
+        NULL,
 };
+ATTRIBUTE_GROUPS(pmib);
 
 static void wpan_phy_release(struct device *d)
 {
@@ -85,7 +88,7 @@ static void wpan_phy_release(struct device *d)
 static struct class wpan_phy_class = {
         .name = "ieee802154",
         .dev_release = wpan_phy_release,
-        .dev_attrs = pmib_attrs,
+        .dev_groups = pmib_groups,
 };
 
 static DEFINE_MUTEX(wpan_phy_mutex);
diff --git a/net/rfkill/core.c b/net/rfkill/core.c
index 1cec5e4f3a5e..1bacc1079942 100644
--- a/net/rfkill/core.c
+++ b/net/rfkill/core.c
@@ -576,14 +576,14 @@ void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
 }
 EXPORT_SYMBOL(rfkill_set_states);
 
-static ssize_t rfkill_name_show(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
+static ssize_t name_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%s\n", rfkill->name);
 }
+static DEVICE_ATTR_RO(name);
 
 static const char *rfkill_get_type_str(enum rfkill_type type)
 {
@@ -611,54 +611,52 @@ static const char *rfkill_get_type_str(enum rfkill_type type)
         }
 }
 
-static ssize_t rfkill_type_show(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
+static ssize_t type_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
 }
+static DEVICE_ATTR_RO(type);
 
-static ssize_t rfkill_idx_show(struct device *dev,
-                               struct device_attribute *attr,
-                               char *buf)
+static ssize_t index_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%d\n", rfkill->idx);
 }
+static DEVICE_ATTR_RO(index);
 
-static ssize_t rfkill_persistent_show(struct device *dev,
-                               struct device_attribute *attr,
-                               char *buf)
+static ssize_t persistent_show(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%d\n", rfkill->persistent);
 }
+static DEVICE_ATTR_RO(persistent);
 
-static ssize_t rfkill_hard_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
+static ssize_t hard_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 );
 }
+static DEVICE_ATTR_RO(hard);
 
-static ssize_t rfkill_soft_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
+static ssize_t soft_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 );
 }
 
-static ssize_t rfkill_soft_store(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
+static ssize_t soft_store(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
 {
         struct rfkill *rfkill = to_rfkill(dev);
         unsigned long state;
@@ -680,6 +678,7 @@ static ssize_t rfkill_soft_store(struct device *dev,
 
         return count;
 }
+static DEVICE_ATTR_RW(soft);
 
 static u8 user_state_from_blocked(unsigned long state)
 {
@@ -691,18 +690,16 @@ static u8 user_state_from_blocked(unsigned long state)
         return RFKILL_USER_STATE_UNBLOCKED;
 }
 
-static ssize_t rfkill_state_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
+static ssize_t state_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         struct rfkill *rfkill = to_rfkill(dev);
 
         return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state));
 }
 
-static ssize_t rfkill_state_store(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
+static ssize_t state_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
         struct rfkill *rfkill = to_rfkill(dev);
         unsigned long state;
@@ -725,32 +722,27 @@ static ssize_t rfkill_state_store(struct device *dev,
 
         return count;
 }
+static DEVICE_ATTR_RW(state);
 
-static ssize_t rfkill_claim_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
+static ssize_t claim_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         return sprintf(buf, "%d\n", 0);
 }
-
-static ssize_t rfkill_claim_store(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
-{
-        return -EOPNOTSUPP;
-}
-
-static struct device_attribute rfkill_dev_attrs[] = {
-        __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
-        __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
-        __ATTR(index, S_IRUGO, rfkill_idx_show, NULL),
-        __ATTR(persistent, S_IRUGO, rfkill_persistent_show, NULL),
-        __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
-        __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
-        __ATTR(soft, S_IRUGO|S_IWUSR, rfkill_soft_show, rfkill_soft_store),
-        __ATTR(hard, S_IRUGO, rfkill_hard_show, NULL),
-        __ATTR_NULL
+static DEVICE_ATTR_RO(claim);
+
+static struct attribute *rfkill_dev_attrs[] = {
+        &dev_attr_name.attr,
+        &dev_attr_type.attr,
+        &dev_attr_index.attr,
+        &dev_attr_persistent.attr,
+        &dev_attr_state.attr,
+        &dev_attr_claim.attr,
+        &dev_attr_soft.attr,
+        &dev_attr_hard.attr,
+        NULL,
 };
+ATTRIBUTE_GROUPS(rfkill_dev);
 
 static void rfkill_release(struct device *dev)
 {
@@ -830,7 +822,7 @@ static int rfkill_resume(struct device *dev)
 static struct class rfkill_class = {
         .name           = "rfkill",
         .dev_release    = rfkill_release,
-        .dev_attrs      = rfkill_dev_attrs,
+        .dev_groups     = rfkill_dev_groups,
         .dev_uevent     = rfkill_dev_uevent,
         .suspend        = rfkill_suspend,
         .resume         = rfkill_resume,
diff --git a/net/wireless/sysfs.c b/net/wireless/sysfs.c
index a23253e06358..9ee6bc1a7610 100644
--- a/net/wireless/sysfs.c
+++ b/net/wireless/sysfs.c
@@ -30,7 +30,8 @@ static ssize_t name ## _show(struct device *dev,			\
                               char *buf)                                \
 {                                                                       \
         return sprintf(buf, fmt "\n", dev_to_rdev(dev)->member);        \
-}
+}                                                                       \
+static DEVICE_ATTR_RO(name)
 
 SHOW_FMT(index, "%d", wiphy_idx);
 SHOW_FMT(macaddress, "%pM", wiphy.perm_addr);
@@ -42,7 +43,7 @@ static ssize_t name_show(struct device *dev,
         struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy;
         return sprintf(buf, "%s\n", dev_name(&wiphy->dev));
 }
-
+static DEVICE_ATTR_RO(name);
 
 static ssize_t addresses_show(struct device *dev,
                               struct device_attribute *attr,
@@ -60,15 +61,17 @@ static ssize_t addresses_show(struct device *dev,
 
         return buf - start;
 }
-
-static struct device_attribute ieee80211_dev_attrs[] = {
-        __ATTR_RO(index),
-        __ATTR_RO(macaddress),
-        __ATTR_RO(address_mask),
-        __ATTR_RO(addresses),
-        __ATTR_RO(name),
-        {}
+static DEVICE_ATTR_RO(addresses);
+
+static struct attribute *ieee80211_attrs[] = {
+        &dev_attr_index.attr,
+        &dev_attr_macaddress.attr,
+        &dev_attr_address_mask.attr,
+        &dev_attr_addresses.attr,
+        &dev_attr_name.attr,
+        NULL,
 };
+ATTRIBUTE_GROUPS(ieee80211);
 
 static void wiphy_dev_release(struct device *dev)
 {
@@ -146,7 +149,7 @@ struct class ieee80211_class = {
         .name = "ieee80211",
         .owner = THIS_MODULE,
         .dev_release = wiphy_dev_release,
-        .dev_attrs = ieee80211_dev_attrs,
+        .dev_groups = ieee80211_groups,
         .dev_uevent = wiphy_uevent,
 #ifdef CONFIG_PM
         .suspend = wiphy_suspend,