From c8fea8d38011ede78e3f86d774886e32272973bb Mon Sep 17 00:00:00 2001 From: Felix Fietkau Date: Sat, 30 Dec 2006 18:47:07 +0000 Subject: add d80211 from a recent wireless-dev checkout SVN-Revision: 5939 --- package/d80211/src/ieee80211_sysfs.c | 787 +++++++++++++++++++++++++++++++++++ 1 file changed, 787 insertions(+) create mode 100644 package/d80211/src/ieee80211_sysfs.c (limited to 'package/d80211/src/ieee80211_sysfs.c') diff --git a/package/d80211/src/ieee80211_sysfs.c b/package/d80211/src/ieee80211_sysfs.c new file mode 100644 index 0000000000..6a60077d7a --- /dev/null +++ b/package/d80211/src/ieee80211_sysfs.c @@ -0,0 +1,787 @@ +/* + * Copyright (c) 2006 Jiri Benc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "ieee80211_i.h" +#include "ieee80211_rate.h" + +#define to_ieee80211_local(class) \ + container_of(class, struct ieee80211_local, class_dev) +#define to_net_dev(class) \ + container_of(class, struct net_device, class_dev) + +static inline int rtnl_lock_local(struct ieee80211_local *local) +{ + rtnl_lock(); + if (unlikely(local->reg_state != IEEE80211_DEV_REGISTERED)) { + rtnl_unlock(); + return -ENODEV; + } + return 0; +} + +static const char *ieee80211_mode_str_short(int mode) +{ + switch (mode) { + case MODE_IEEE80211A: + return "802.11a"; + case MODE_IEEE80211B: + return "802.11b"; + case MODE_IEEE80211G: + return "802.11g"; + case MODE_ATHEROS_TURBO: + return "AtherosTurbo"; + default: + return "UNKNOWN"; + } +} + +static const char *ieee80211_mode_str(int mode) +{ + switch (mode) { + case MODE_IEEE80211A: + return "IEEE 802.11a"; + case MODE_IEEE80211B: + return "IEEE 802.11b"; + case MODE_IEEE80211G: + return "IEEE 802.11g"; + case MODE_ATHEROS_TURBO: + return "Atheros Turbo (5 GHz)"; + default: + return "UNKNOWN"; + } +} + +/* attributes in /sys/class/ieee80211/phyX/ */ + +static ssize_t store_add_iface(struct class_device *dev, + const char *buf, size_t len) +{ + struct ieee80211_local *local = to_ieee80211_local(dev); + struct net_device *new_dev; + int res; + + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (len > IFNAMSIZ) + return -EINVAL; + res = rtnl_lock_local(local); + if (res) + return res; + res = ieee80211_if_add(local->mdev, buf, 0, &new_dev); + if (res == 0) + ieee80211_if_set_type(new_dev, IEEE80211_IF_TYPE_STA); + rtnl_unlock(); + return res < 0 ? res : len; +} + +static ssize_t store_remove_iface(struct class_device *dev, + const char *buf, size_t len) +{ + struct ieee80211_local *local = to_ieee80211_local(dev); + int res; + + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (len > IFNAMSIZ) + return -EINVAL; + res = rtnl_lock_local(local); + if (res) + return res; + res = ieee80211_if_remove(local->mdev, buf, -1); + rtnl_unlock(); + return res < 0 ? res : len; +} + +static ssize_t store_rate_ctrl_alg(struct class_device *dev, + const char *buf, size_t len) +{ + struct ieee80211_local *local = to_ieee80211_local(dev); + int res; + + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + res = rtnl_lock_local(local); + if (res) + return res; + res = ieee80211_init_rate_ctrl_alg(local, buf); + rtnl_unlock(); + return res < 0 ? res : len; +} + +static ssize_t ieee80211_local_show(struct class_device *dev, char *buf, + ssize_t (*format)(struct ieee80211_local *, char *)) +{ + struct ieee80211_local *local = to_ieee80211_local(dev); + ssize_t ret = -EINVAL; + + if (local->reg_state == IEEE80211_DEV_REGISTERED) + ret = (*format)(local, buf); + return ret; +} + +#define IEEE80211_LOCAL_FMT(name, field, format_string) \ +static ssize_t ieee80211_local_fmt_##name(struct ieee80211_local *local,\ + char *buf) \ +{ \ + return sprintf(buf, format_string, local->field); \ +} + +#define __IEEE80211_LOCAL_SHOW(name) \ +static ssize_t ieee80211_local_show_##name(struct class_device *cd, \ + char *buf) \ +{ \ + return ieee80211_local_show(cd, buf, \ + ieee80211_local_fmt_##name); \ +} + +#define IEEE80211_LOCAL_SHOW(name, field, format) \ + IEEE80211_LOCAL_FMT(name, field, format "\n") \ + __IEEE80211_LOCAL_SHOW(name) + +IEEE80211_LOCAL_SHOW(channel, hw.conf.channel, "%d"); +IEEE80211_LOCAL_SHOW(frequency, hw.conf.freq, "%d"); +IEEE80211_LOCAL_SHOW(radar_detect, hw.conf.radar_detect, "%d"); +IEEE80211_LOCAL_SHOW(antenna_sel, hw.conf.antenna_sel, "%d"); +IEEE80211_LOCAL_SHOW(bridge_packets, bridge_packets, "%d"); +IEEE80211_LOCAL_SHOW(key_tx_rx_threshold, key_tx_rx_threshold, "%d"); +IEEE80211_LOCAL_SHOW(rts_threshold, rts_threshold, "%d"); +IEEE80211_LOCAL_SHOW(fragmentation_threshold, fragmentation_threshold, "%d"); +IEEE80211_LOCAL_SHOW(short_retry_limit, short_retry_limit, "%d"); +IEEE80211_LOCAL_SHOW(long_retry_limit, long_retry_limit, "%d"); +IEEE80211_LOCAL_SHOW(total_ps_buffered, total_ps_buffered, "%d"); + +static ssize_t ieee80211_local_fmt_mode(struct ieee80211_local *local, + char *buf) +{ + return sprintf(buf, "%s\n", ieee80211_mode_str(local->hw.conf.phymode)); +} +__IEEE80211_LOCAL_SHOW(mode); + +static ssize_t ieee80211_local_fmt_wep_iv(struct ieee80211_local *local, + char *buf) +{ + return sprintf(buf, "%#06x\n", local->wep_iv & 0xffffff); +} +__IEEE80211_LOCAL_SHOW(wep_iv); + +static ssize_t ieee80211_local_fmt_tx_power_reduction(struct ieee80211_local + *local, char *buf) +{ + short tx_power_reduction = local->hw.conf.tx_power_reduction; + + return sprintf(buf, "%d.%d dBm\n", tx_power_reduction / 10, + tx_power_reduction % 10); +} +__IEEE80211_LOCAL_SHOW(tx_power_reduction); + +static ssize_t ieee80211_local_fmt_modes(struct ieee80211_local *local, + char *buf) +{ + int i; + struct ieee80211_hw_modes *mode; + char *p = buf; + + /* FIXME: locking against ieee80211_update_hw? */ + for (i = 0; i < local->hw.num_modes; i++) { + mode = &local->hw.modes[i]; + p += sprintf(p, "%s\n", ieee80211_mode_str_short(mode->mode)); + } + return (p - buf); +} +__IEEE80211_LOCAL_SHOW(modes); + +static ssize_t ieee80211_local_fmt_rate_ctrl_alg(struct ieee80211_local *local, + char *buf) +{ + struct rate_control_ref *ref = local->rate_ctrl; + if (ref) + return sprintf(buf, "%s\n", ref->ops->name); + return 0; +} +__IEEE80211_LOCAL_SHOW(rate_ctrl_alg); + +static struct class_device_attribute ieee80211_class_dev_attrs[] = { + __ATTR(add_iface, S_IWUGO, NULL, store_add_iface), + __ATTR(remove_iface, S_IWUGO, NULL, store_remove_iface), + __ATTR(channel, S_IRUGO, ieee80211_local_show_channel, NULL), + __ATTR(frequency, S_IRUGO, ieee80211_local_show_frequency, NULL), + __ATTR(radar_detect, S_IRUGO, ieee80211_local_show_radar_detect, NULL), + __ATTR(antenna_sel, S_IRUGO, ieee80211_local_show_antenna_sel, NULL), + __ATTR(bridge_packets, S_IRUGO, ieee80211_local_show_bridge_packets, NULL), + __ATTR(key_tx_rx_threshold, S_IRUGO, ieee80211_local_show_key_tx_rx_threshold, NULL), + __ATTR(rts_threshold, S_IRUGO, ieee80211_local_show_rts_threshold, NULL), + __ATTR(fragmentation_threshold, S_IRUGO, ieee80211_local_show_fragmentation_threshold, NULL), + __ATTR(short_retry_limit, S_IRUGO, ieee80211_local_show_short_retry_limit, NULL), + __ATTR(long_retry_limit, S_IRUGO, ieee80211_local_show_long_retry_limit, NULL), + __ATTR(total_ps_buffered, S_IRUGO, ieee80211_local_show_total_ps_buffered, NULL), + __ATTR(mode, S_IRUGO, ieee80211_local_show_mode, NULL), + __ATTR(wep_iv, S_IRUGO, ieee80211_local_show_wep_iv, NULL), + __ATTR(tx_power_reduction, S_IRUGO, ieee80211_local_show_tx_power_reduction, NULL), + __ATTR(modes, S_IRUGO, ieee80211_local_show_modes, NULL), + __ATTR(rate_ctrl_alg, S_IRUGO | S_IWUGO, ieee80211_local_show_rate_ctrl_alg, store_rate_ctrl_alg), + {} +}; + +/* attributes in /sys/class/ieee80211/phyX/statistics/ */ + +#define IEEE80211_LOCAL_ATTR(name, field, format) \ +IEEE80211_LOCAL_SHOW(name, field, format) \ +static CLASS_DEVICE_ATTR(name, S_IRUGO, ieee80211_local_show_##name, NULL); + +IEEE80211_LOCAL_ATTR(transmitted_fragment_count, dot11TransmittedFragmentCount, "%u"); +IEEE80211_LOCAL_ATTR(multicast_transmitted_frame_count, dot11MulticastTransmittedFrameCount, "%u"); +IEEE80211_LOCAL_ATTR(failed_count, dot11FailedCount, "%u"); +IEEE80211_LOCAL_ATTR(retry_count, dot11RetryCount, "%u"); +IEEE80211_LOCAL_ATTR(multiple_retry_count, dot11MultipleRetryCount, "%u"); +IEEE80211_LOCAL_ATTR(frame_duplicate_count, dot11FrameDuplicateCount, "%u"); +IEEE80211_LOCAL_ATTR(received_fragment_count, dot11ReceivedFragmentCount, "%u"); +IEEE80211_LOCAL_ATTR(multicast_received_frame_count, dot11MulticastReceivedFrameCount, "%u"); +IEEE80211_LOCAL_ATTR(transmitted_frame_count, dot11TransmittedFrameCount, "%u"); +IEEE80211_LOCAL_ATTR(wep_undecryptable_count, dot11WEPUndecryptableCount, "%u"); +IEEE80211_LOCAL_ATTR(num_scans, scan.num_scans, "%u"); + +#ifdef CONFIG_D80211_DEBUG_COUNTERS +IEEE80211_LOCAL_ATTR(tx_handlers_drop, tx_handlers_drop, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_queued, tx_handlers_queued, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_drop_unencrypted, tx_handlers_drop_unencrypted, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_drop_fragment, tx_handlers_drop_fragment, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_drop_wep, tx_handlers_drop_wep, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_drop_not_assoc, tx_handlers_drop_not_assoc, "%u"); +IEEE80211_LOCAL_ATTR(tx_handlers_drop_unauth_port, tx_handlers_drop_unauth_port, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_drop, rx_handlers_drop, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_queued, rx_handlers_queued, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_drop_nullfunc, rx_handlers_drop_nullfunc, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_drop_defrag, rx_handlers_drop_defrag, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_drop_short, rx_handlers_drop_short, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_drop_passive_scan, rx_handlers_drop_passive_scan, "%u"); +IEEE80211_LOCAL_ATTR(tx_expand_skb_head, tx_expand_skb_head, "%u"); +IEEE80211_LOCAL_ATTR(tx_expand_skb_head_cloned, tx_expand_skb_head_cloned, "%u"); +IEEE80211_LOCAL_ATTR(rx_expand_skb_head, rx_expand_skb_head, "%u"); +IEEE80211_LOCAL_ATTR(rx_expand_skb_head2, rx_expand_skb_head2, "%u"); +IEEE80211_LOCAL_ATTR(rx_handlers_fragments, rx_handlers_fragments, "%u"); +IEEE80211_LOCAL_ATTR(tx_status_drop, tx_status_drop, "%u"); + +static ssize_t ieee80211_local_fmt_wme_rx_queue(struct ieee80211_local *local, + char *buf) +{ + int i; + char *p = buf; + + for (i = 0; i < NUM_RX_DATA_QUEUES; i++) + p += sprintf(p, "%u\n", local->wme_rx_queue[i]); + return (p - buf); +} +__IEEE80211_LOCAL_SHOW(wme_rx_queue); +static CLASS_DEVICE_ATTR(wme_rx_queue, S_IRUGO, + ieee80211_local_show_wme_rx_queue, NULL); + +static ssize_t ieee80211_local_fmt_wme_tx_queue(struct ieee80211_local *local, + char *buf) +{ + int i; + char *p = buf; + + for (i = 0; i < NUM_RX_DATA_QUEUES; i++) + p += sprintf(p, "%u\n", local->wme_tx_queue[i]); + return (p - buf); +} +__IEEE80211_LOCAL_SHOW(wme_tx_queue); +static CLASS_DEVICE_ATTR(wme_tx_queue, S_IRUGO, + ieee80211_local_show_wme_tx_queue, NULL); +#endif + +static ssize_t ieee80211_stats_show(struct class_device *dev, char *buf, + ssize_t (*format)(struct ieee80211_low_level_stats *, char *)) +{ + struct ieee80211_local *local = to_ieee80211_local(dev); + struct ieee80211_low_level_stats stats; + ssize_t ret = -EINVAL; + + if (!local->ops->get_stats) + return -EOPNOTSUPP; + ret = rtnl_lock_local(local); + if (ret) + return ret; + ret = local->ops->get_stats(local_to_hw(local), &stats); + rtnl_unlock(); + if (!ret) + ret = (*format)(&stats, buf); + return ret; +} + +#define IEEE80211_STATS_FMT(name, field, format_string) \ +static ssize_t ieee80211_stats_fmt_##name(struct ieee80211_low_level_stats \ + *stats, char *buf) \ +{ \ + return sprintf(buf, format_string, stats->field); \ +} + +#define __IEEE80211_STATS_SHOW(name) \ +static ssize_t ieee80211_stats_show_##name(struct class_device *cd, \ + char *buf) \ +{ \ + return ieee80211_stats_show(cd, buf, \ + ieee80211_stats_fmt_##name); \ +} + +#define IEEE80211_STATS_ATTR(name, field, format) \ +IEEE80211_STATS_FMT(name, field, format "\n") \ +__IEEE80211_STATS_SHOW(name) \ +static CLASS_DEVICE_ATTR(name, S_IRUGO, ieee80211_stats_show_##name, NULL); + +IEEE80211_STATS_ATTR(ack_failure_count, dot11ACKFailureCount, "%u"); +IEEE80211_STATS_ATTR(rts_failure_count, dot11RTSFailureCount, "%u"); +IEEE80211_STATS_ATTR(fcs_error_count, dot11FCSErrorCount, "%u"); +IEEE80211_STATS_ATTR(rts_success_count, dot11RTSSuccessCount, "%u"); + +static struct attribute *ieee80211_stats_attrs[] = { + &class_device_attr_transmitted_fragment_count.attr, + &class_device_attr_multicast_transmitted_frame_count.attr, + &class_device_attr_failed_count.attr, + &class_device_attr_retry_count.attr, + &class_device_attr_multiple_retry_count.attr, + &class_device_attr_frame_duplicate_count.attr, + &class_device_attr_received_fragment_count.attr, + &class_device_attr_multicast_received_frame_count.attr, + &class_device_attr_transmitted_frame_count.attr, + &class_device_attr_wep_undecryptable_count.attr, + &class_device_attr_ack_failure_count.attr, + &class_device_attr_rts_failure_count.attr, + &class_device_attr_fcs_error_count.attr, + &class_device_attr_rts_success_count.attr, + &class_device_attr_num_scans.attr, +#ifdef CONFIG_D80211_DEBUG_COUNTERS + &class_device_attr_tx_handlers_drop.attr, + &class_device_attr_tx_handlers_queued.attr, + &class_device_attr_tx_handlers_drop_unencrypted.attr, + &class_device_attr_tx_handlers_drop_fragment.attr, + &class_device_attr_tx_handlers_drop_wep.attr, + &class_device_attr_tx_handlers_drop_not_assoc.attr, + &class_device_attr_tx_handlers_drop_unauth_port.attr, + &class_device_attr_rx_handlers_drop.attr, + &class_device_attr_rx_handlers_queued.attr, + &class_device_attr_rx_handlers_drop_nullfunc.attr, + &class_device_attr_rx_handlers_drop_defrag.attr, + &class_device_attr_rx_handlers_drop_short.attr, + &class_device_attr_rx_handlers_drop_passive_scan.attr, + &class_device_attr_tx_expand_skb_head.attr, + &class_device_attr_tx_expand_skb_head_cloned.attr, + &class_device_attr_rx_expand_skb_head.attr, + &class_device_attr_rx_expand_skb_head2.attr, + &class_device_attr_rx_handlers_fragments.attr, + &class_device_attr_tx_status_drop.attr, + &class_device_attr_wme_rx_queue.attr, + &class_device_attr_wme_tx_queue.attr, +#endif + NULL, +}; + +static struct attribute_group ieee80211_stats_group = { + .name = "statistics", + .attrs = ieee80211_stats_attrs, +}; + +/* attributes in /sys/class/net/X/ */ + +static ssize_t ieee80211_if_show(struct class_device *cd, char *buf, + ssize_t (*format)(const struct ieee80211_sub_if_data *, + char *)) +{ + struct net_device *dev = to_net_dev(cd); + struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); + ssize_t ret = -EINVAL; + + read_lock(&dev_base_lock); + if (dev->reg_state == NETREG_REGISTERED) { + ret = (*format)(sdata, buf); + } + read_unlock(&dev_base_lock); + return ret; +} + +#define IEEE80211_IF_FMT(name, field, format_string) \ +static ssize_t ieee80211_if_fmt_##name(const struct \ + ieee80211_sub_if_data *sdata, char *buf) \ +{ \ + return sprintf(buf, format_string, sdata->field); \ +} +#define IEEE80211_IF_FMT_DEC(name, field) \ + IEEE80211_IF_FMT(name, field, "%d\n") +#define IEEE80211_IF_FMT_HEX(name, field) \ + IEEE80211_IF_FMT(name, field, "%#x\n") +#define IEEE80211_IF_FMT_SIZE(name, field) \ + IEEE80211_IF_FMT(name, field, "%zd\n") + +#define IEEE80211_IF_FMT_ATOMIC(name, field) \ +static ssize_t ieee80211_if_fmt_##name(const struct \ + ieee80211_sub_if_data *sdata, char *buf) \ +{ \ + return sprintf(buf, "%d\n", atomic_read(&sdata->field)); \ +} + +#define IEEE80211_IF_FMT_MAC(name, field) \ +static ssize_t ieee80211_if_fmt_##name(const struct \ + ieee80211_sub_if_data *sdata, char *buf) \ +{ \ + return sprintf(buf, MAC_FMT "\n", MAC_ARG(sdata->field)); \ +} + +#define __IEEE80211_IF_SHOW(name) \ +static ssize_t ieee80211_if_show_##name(struct class_device *cd, \ + char *buf) \ +{ \ + return ieee80211_if_show(cd, buf, ieee80211_if_fmt_##name); \ +} \ +static CLASS_DEVICE_ATTR(name, S_IRUGO, ieee80211_if_show_##name, NULL); + +#define IEEE80211_IF_SHOW(name, field, format) \ + IEEE80211_IF_FMT_##format(name, field) \ + __IEEE80211_IF_SHOW(name) + +/* common attributes */ +IEEE80211_IF_SHOW(channel_use, channel_use, DEC); +IEEE80211_IF_SHOW(drop_unencrypted, drop_unencrypted, DEC); +IEEE80211_IF_SHOW(eapol, eapol, DEC); +IEEE80211_IF_SHOW(ieee8021_x, ieee802_1x, DEC); + +/* STA/IBSS attributes */ +IEEE80211_IF_SHOW(state, u.sta.state, DEC); +IEEE80211_IF_SHOW(bssid, u.sta.bssid, MAC); +IEEE80211_IF_SHOW(prev_bssid, u.sta.prev_bssid, MAC); +IEEE80211_IF_SHOW(ssid_len, u.sta.ssid_len, SIZE); +IEEE80211_IF_SHOW(aid, u.sta.aid, DEC); +IEEE80211_IF_SHOW(ap_capab, u.sta.ap_capab, HEX); +IEEE80211_IF_SHOW(capab, u.sta.capab, HEX); +IEEE80211_IF_SHOW(extra_ie_len, u.sta.extra_ie_len, SIZE); +IEEE80211_IF_SHOW(auth_tries, u.sta.auth_tries, DEC); +IEEE80211_IF_SHOW(assoc_tries, u.sta.assoc_tries, DEC); +IEEE80211_IF_SHOW(auth_algs, u.sta.auth_algs, HEX); +IEEE80211_IF_SHOW(auth_alg, u.sta.auth_alg, DEC); +IEEE80211_IF_SHOW(auth_transaction, u.sta.auth_transaction, DEC); + +static ssize_t ieee80211_if_fmt_flags(const struct + ieee80211_sub_if_data *sdata, char *buf) +{ + return sprintf(buf, "%s%s%s%s%s%s%s\n", + sdata->u.sta.ssid_set ? "SSID\n" : "", + sdata->u.sta.bssid_set ? "BSSID\n" : "", + sdata->u.sta.prev_bssid_set ? "prev BSSID\n" : "", + sdata->u.sta.authenticated ? "AUTH\n" : "", + sdata->u.sta.associated ? "ASSOC\n" : "", + sdata->u.sta.probereq_poll ? "PROBEREQ POLL\n" : "", + sdata->u.sta.use_protection ? "CTS prot\n" : ""); +} +__IEEE80211_IF_SHOW(flags); + +/* AP attributes */ +IEEE80211_IF_SHOW(num_sta_ps, u.ap.num_sta_ps, ATOMIC); +IEEE80211_IF_SHOW(dtim_period, u.ap.dtim_period, DEC); +IEEE80211_IF_SHOW(dtim_count, u.ap.dtim_count, DEC); +IEEE80211_IF_SHOW(num_beacons, u.ap.num_beacons, DEC); +IEEE80211_IF_SHOW(force_unicast_rateidx, u.ap.force_unicast_rateidx, DEC); +IEEE80211_IF_SHOW(max_ratectrl_rateidx, u.ap.max_ratectrl_rateidx, DEC); + +static ssize_t ieee80211_if_fmt_num_buffered_multicast(const struct + ieee80211_sub_if_data *sdata, char *buf) +{ + return sprintf(buf, "%u\n", skb_queue_len(&sdata->u.ap.ps_bc_buf)); +} +__IEEE80211_IF_SHOW(num_buffered_multicast); + +static ssize_t ieee80211_if_fmt_beacon_head_len(const struct + ieee80211_sub_if_data *sdata, char *buf) +{ + if (sdata->u.ap.beacon_head) + return sprintf(buf, "%d\n", sdata->u.ap.beacon_head_len); + return sprintf(buf, "\n"); +} +__IEEE80211_IF_SHOW(beacon_head_len); + +static ssize_t ieee80211_if_fmt_beacon_tail_len(const struct + ieee80211_sub_if_data *sdata, char *buf) +{ + if (sdata->u.ap.beacon_tail) + return sprintf(buf, "%d\n", sdata->u.ap.beacon_tail_len); + return sprintf(buf, "\n"); +} +__IEEE80211_IF_SHOW(beacon_tail_len); + +/* WDS attributes */ +IEEE80211_IF_SHOW(peer, u.wds.remote_addr, MAC); + +/* VLAN attributes */ +IEEE80211_IF_SHOW(vlan_id, u.vlan.id, DEC); + +/* MONITOR attributes */ +static ssize_t ieee80211_if_fmt_mode(const struct + ieee80211_sub_if_data *sdata, char *buf) +{ + struct ieee80211_local *local = sdata->local; + + return sprintf(buf, "%s\n", + ((local->hw.flags & IEEE80211_HW_MONITOR_DURING_OPER) || + local->open_count == local->monitors) ? + "hard" : "soft"); +} +__IEEE80211_IF_SHOW(mode); + +static struct attribute *ieee80211_sta_attrs[] = { + &class_device_attr_channel_use.attr, + &class_device_attr_drop_unencrypted.attr, + &class_device_attr_eapol.attr, + &class_device_attr_ieee8021_x.attr, + &class_device_attr_state.attr, + &class_device_attr_bssid.attr, + &class_device_attr_prev_bssid.attr, + &class_device_attr_ssid_len.attr, + &class_device_attr_aid.attr, + &class_device_attr_ap_capab.attr, + &class_device_attr_capab.attr, + &class_device_attr_extra_ie_len.attr, + &class_device_attr_auth_tries.attr, + &class_device_attr_assoc_tries.attr, + &class_device_attr_auth_algs.attr, + &class_device_attr_auth_alg.attr, + &class_device_attr_auth_transaction.attr, + &class_device_attr_flags.attr, + NULL +}; + +static struct attribute *ieee80211_ap_attrs[] = { + &class_device_attr_channel_use.attr, + &class_device_attr_drop_unencrypted.attr, + &class_device_attr_eapol.attr, + &class_device_attr_ieee8021_x.attr, + &class_device_attr_num_sta_ps.attr, + &class_device_attr_dtim_period.attr, + &class_device_attr_dtim_count.attr, + &class_device_attr_num_beacons.attr, + &class_device_attr_force_unicast_rateidx.attr, + &class_device_attr_max_ratectrl_rateidx.attr, + &class_device_attr_num_buffered_multicast.attr, + &class_device_attr_beacon_head_len.attr, + &class_device_attr_beacon_tail_len.attr, + NULL +}; + +static struct attribute *ieee80211_wds_attrs[] = { + &class_device_attr_channel_use.attr, + &class_device_attr_drop_unencrypted.attr, + &class_device_attr_eapol.attr, + &class_device_attr_ieee8021_x.attr, + &class_device_attr_peer.attr, + NULL +}; + +static struct attribute *ieee80211_vlan_attrs[] = { + &class_device_attr_channel_use.attr, + &class_device_attr_drop_unencrypted.attr, + &class_device_attr_eapol.attr, + &class_device_attr_ieee8021_x.attr, + &class_device_attr_vlan_id.attr, + NULL +}; + +static struct attribute *ieee80211_monitor_attrs[] = { + &class_device_attr_mode.attr, + NULL +}; + +static struct attribute_group ieee80211_sta_group = { + .name = "sta", + .attrs = ieee80211_sta_attrs, +}; + +static struct attribute_group ieee80211_ap_group = { + .name = "ap", + .attrs = ieee80211_ap_attrs, +}; + +static struct attribute_group ieee80211_wds_group = { + .name = "wds", + .attrs = ieee80211_wds_attrs, +}; + +static struct attribute_group ieee80211_vlan_group = { + .name = "vlan", + .attrs = ieee80211_vlan_attrs, +}; + +static struct attribute_group ieee80211_monitor_group = { + .name = "monitor", + .attrs = ieee80211_monitor_attrs, +}; + +/* /sys/class/ieee80211/phyX functions */ + +static void ieee80211_class_dev_release(struct class_device *dev) +{ + ieee80211_release_hw(to_ieee80211_local(dev)); +} + +#ifdef CONFIG_HOTPLUG +static int ieee80211_uevent(struct class_device *cd, char **envp, + int num_envp, char *buf, int size) +{ + struct ieee80211_local *local = to_ieee80211_local(cd); + + if (num_envp < 2) + return -ENOMEM; + envp[0] = buf; + if (snprintf(buf, size, "IEEE80211_DEV=phy%d", + local->hw.index) + 1 >= size) + return -ENOMEM; + envp[1] = NULL; + return 0; +} +#endif + +static struct class ieee80211_class = { + .name = "ieee80211", + .class_dev_attrs = ieee80211_class_dev_attrs, + .release = ieee80211_class_dev_release, +#ifdef CONFIG_HOTPLUG + .uevent = ieee80211_uevent, +#endif +}; + +void ieee80211_dev_sysfs_init(struct ieee80211_local *local) +{ + local->class_dev.class = &ieee80211_class; + local->class_dev.class_data = local; + class_device_initialize(&local->class_dev); +} + +void ieee80211_dev_sysfs_put(struct ieee80211_local *local) +{ + class_device_put(&local->class_dev); +} + +int ieee80211_dev_sysfs_add(struct ieee80211_local *local) +{ + int res; + + snprintf(local->class_dev.class_id, BUS_ID_SIZE, + "phy%d", local->hw.index); + res = class_device_add(&local->class_dev); + if (res) + return res; + res = sysfs_create_group(&local->class_dev.kobj, + &ieee80211_stats_group); + if (res) + class_device_del(&local->class_dev); + return res; +} + +void ieee80211_dev_sysfs_del(struct ieee80211_local *local) +{ + sysfs_remove_group(&local->class_dev.kobj, &ieee80211_stats_group); + class_device_del(&local->class_dev); +} + +/* /sys/class/net/X functions */ + +static void __ieee80211_remove_if_group(struct kobject *kobj, + struct ieee80211_sub_if_data *sdata) +{ + if (sdata->sysfs_group) { + sysfs_remove_group(kobj, sdata->sysfs_group); + sdata->sysfs_group = NULL; + } +} + +static inline void ieee80211_remove_if_group(struct kobject *kobj, + struct net_device *dev) +{ + __ieee80211_remove_if_group(kobj, IEEE80211_DEV_TO_SUB_IF(dev)); +} + +static int ieee80211_add_if_group(struct kobject *kobj, + struct net_device *dev) +{ + struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); + int res = 0; + + __ieee80211_remove_if_group(kobj, sdata); + switch (sdata->type) { + case IEEE80211_IF_TYPE_STA: + sdata->sysfs_group = &ieee80211_sta_group; + break; + case IEEE80211_IF_TYPE_AP: + sdata->sysfs_group = &ieee80211_ap_group; + break; + case IEEE80211_IF_TYPE_WDS: + sdata->sysfs_group = &ieee80211_wds_group; + break; + case IEEE80211_IF_TYPE_VLAN: + sdata->sysfs_group = &ieee80211_vlan_group; + break; + case IEEE80211_IF_TYPE_MNTR: + sdata->sysfs_group = &ieee80211_monitor_group; + break; + default: + goto out; + } + res = sysfs_create_group(kobj, sdata->sysfs_group); + if (res) + sdata->sysfs_group = NULL; +out: + return res; +} + +int ieee80211_sysfs_change_if_type(struct net_device *dev) +{ + return ieee80211_add_if_group(&dev->class_dev.kobj, dev); +} + +int ieee80211_sysfs_add_netdevice(struct net_device *dev) +{ + struct ieee80211_local *local = dev->ieee80211_ptr; + int res; + + res = sysfs_create_link(&dev->class_dev.kobj, &local->class_dev.kobj, + "hw"); + if (res) + goto err_out; + res = ieee80211_add_if_group(&dev->class_dev.kobj, dev); + if (res) + goto err_link; + res = ieee80211_key_kset_sysfs_register(IEEE80211_DEV_TO_SUB_IF(dev)); + return res; + +err_link: + sysfs_remove_link(&dev->class_dev.kobj, "hw"); +err_out: + return res; +} + +void ieee80211_sysfs_remove_netdevice(struct net_device *dev) +{ + ieee80211_key_kset_sysfs_unregister(IEEE80211_DEV_TO_SUB_IF(dev)); + ieee80211_remove_if_group(&dev->class_dev.kobj, dev); + sysfs_remove_link(&dev->class_dev.kobj, "hw"); +} + +/* general module functions */ + +int ieee80211_sysfs_init(void) +{ + return class_register(&ieee80211_class); +} + +void ieee80211_sysfs_deinit(void) +{ + class_unregister(&ieee80211_class); +} -- cgit v1.2.3