|
|
@@ -1,70 +1,217 @@
|
|
|
#ifndef __NET_CFG80211_H
|
|
|
#define __NET_CFG80211_H
|
|
|
+/*
|
|
|
+ * 802.11 device and configuration interface
|
|
|
+ *
|
|
|
+ * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
|
|
|
+ *
|
|
|
+ * 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 <linux/netdevice.h>
|
|
|
+#include <linux/debugfs.h>
|
|
|
+#include <linux/list.h>
|
|
|
#include <linux/netlink.h>
|
|
|
#include <linux/skbuff.h>
|
|
|
#include <linux/nl80211.h>
|
|
|
#include <linux/if_ether.h>
|
|
|
#include <linux/ieee80211.h>
|
|
|
-#include <linux/wireless.h>
|
|
|
-#include <net/iw_handler.h>
|
|
|
-#include <net/genetlink.h>
|
|
|
+#include <net/regulatory.h>
|
|
|
+
|
|
|
/* remove once we remove the wext stuff */
|
|
|
+#include <net/iw_handler.h>
|
|
|
+#include <linux/wireless.h>
|
|
|
+
|
|
|
|
|
|
/*
|
|
|
- * 802.11 configuration in-kernel interface
|
|
|
+ * wireless hardware capability structures
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * enum ieee80211_band - supported frequency bands
|
|
|
+ *
|
|
|
+ * The bands are assigned this way because the supported
|
|
|
+ * bitrates differ in these bands.
|
|
|
*
|
|
|
- * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
|
|
|
+ * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band
|
|
|
+ * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7)
|
|
|
*/
|
|
|
+enum ieee80211_band {
|
|
|
+ IEEE80211_BAND_2GHZ,
|
|
|
+ IEEE80211_BAND_5GHZ,
|
|
|
+
|
|
|
+ /* keep last */
|
|
|
+ IEEE80211_NUM_BANDS
|
|
|
+};
|
|
|
|
|
|
/**
|
|
|
- * struct vif_params - describes virtual interface parameters
|
|
|
- * @mesh_id: mesh ID to use
|
|
|
- * @mesh_id_len: length of the mesh ID
|
|
|
+ * enum ieee80211_channel_flags - channel flags
|
|
|
+ *
|
|
|
+ * Channel flags set by the regulatory control code.
|
|
|
+ *
|
|
|
+ * @IEEE80211_CHAN_DISABLED: This channel is disabled.
|
|
|
+ * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted
|
|
|
+ * on this channel.
|
|
|
+ * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel.
|
|
|
+ * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
|
|
|
+ * @IEEE80211_CHAN_NO_FAT_ABOVE: extension channel above this channel
|
|
|
+ * is not permitted.
|
|
|
+ * @IEEE80211_CHAN_NO_FAT_BELOW: extension channel below this channel
|
|
|
+ * is not permitted.
|
|
|
*/
|
|
|
-struct vif_params {
|
|
|
- u8 *mesh_id;
|
|
|
- int mesh_id_len;
|
|
|
+enum ieee80211_channel_flags {
|
|
|
+ IEEE80211_CHAN_DISABLED = 1<<0,
|
|
|
+ IEEE80211_CHAN_PASSIVE_SCAN = 1<<1,
|
|
|
+ IEEE80211_CHAN_NO_IBSS = 1<<2,
|
|
|
+ IEEE80211_CHAN_RADAR = 1<<3,
|
|
|
+ IEEE80211_CHAN_NO_FAT_ABOVE = 1<<4,
|
|
|
+ IEEE80211_CHAN_NO_FAT_BELOW = 1<<5,
|
|
|
};
|
|
|
|
|
|
-/* Radiotap header iteration
|
|
|
- * implemented in net/wireless/radiotap.c
|
|
|
- * docs in Documentation/networking/radiotap-headers.txt
|
|
|
+/**
|
|
|
+ * struct ieee80211_channel - channel definition
|
|
|
+ *
|
|
|
+ * This structure describes a single channel for use
|
|
|
+ * with cfg80211.
|
|
|
+ *
|
|
|
+ * @center_freq: center frequency in MHz
|
|
|
+ * @max_bandwidth: maximum allowed bandwidth for this channel, in MHz
|
|
|
+ * @hw_value: hardware-specific value for the channel
|
|
|
+ * @flags: channel flags from &enum ieee80211_channel_flags.
|
|
|
+ * @orig_flags: channel flags at registration time, used by regulatory
|
|
|
+ * code to support devices with additional restrictions
|
|
|
+ * @band: band this channel belongs to.
|
|
|
+ * @max_antenna_gain: maximum antenna gain in dBi
|
|
|
+ * @max_power: maximum transmission power (in dBm)
|
|
|
+ * @beacon_found: helper to regulatory code to indicate when a beacon
|
|
|
+ * has been found on this channel. Use regulatory_hint_found_beacon()
|
|
|
+ * to enable this, this is is useful only on 5 GHz band.
|
|
|
+ * @orig_mag: internal use
|
|
|
+ * @orig_mpwr: internal use
|
|
|
*/
|
|
|
+struct ieee80211_channel {
|
|
|
+ enum ieee80211_band band;
|
|
|
+ u16 center_freq;
|
|
|
+ u8 max_bandwidth;
|
|
|
+ u16 hw_value;
|
|
|
+ u32 flags;
|
|
|
+ int max_antenna_gain;
|
|
|
+ int max_power;
|
|
|
+ bool beacon_found;
|
|
|
+ u32 orig_flags;
|
|
|
+ int orig_mag, orig_mpwr;
|
|
|
+};
|
|
|
+
|
|
|
/**
|
|
|
- * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
|
|
|
- * @rtheader: pointer to the radiotap header we are walking through
|
|
|
- * @max_length: length of radiotap header in cpu byte ordering
|
|
|
- * @this_arg_index: IEEE80211_RADIOTAP_... index of current arg
|
|
|
- * @this_arg: pointer to current radiotap arg
|
|
|
- * @arg_index: internal next argument index
|
|
|
- * @arg: internal next argument pointer
|
|
|
- * @next_bitmap: internal pointer to next present u32
|
|
|
- * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
|
|
|
+ * enum ieee80211_rate_flags - rate flags
|
|
|
+ *
|
|
|
+ * Hardware/specification flags for rates. These are structured
|
|
|
+ * in a way that allows using the same bitrate structure for
|
|
|
+ * different bands/PHY modes.
|
|
|
+ *
|
|
|
+ * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
|
|
|
+ * preamble on this bitrate; only relevant in 2.4GHz band and
|
|
|
+ * with CCK rates.
|
|
|
+ * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
|
|
|
+ * when used with 802.11a (on the 5 GHz band); filled by the
|
|
|
+ * core code when registering the wiphy.
|
|
|
+ * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
|
|
|
+ * when used with 802.11b (on the 2.4 GHz band); filled by the
|
|
|
+ * core code when registering the wiphy.
|
|
|
+ * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
|
|
|
+ * when used with 802.11g (on the 2.4 GHz band); filled by the
|
|
|
+ * core code when registering the wiphy.
|
|
|
+ * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
|
|
|
*/
|
|
|
+enum ieee80211_rate_flags {
|
|
|
+ IEEE80211_RATE_SHORT_PREAMBLE = 1<<0,
|
|
|
+ IEEE80211_RATE_MANDATORY_A = 1<<1,
|
|
|
+ IEEE80211_RATE_MANDATORY_B = 1<<2,
|
|
|
+ IEEE80211_RATE_MANDATORY_G = 1<<3,
|
|
|
+ IEEE80211_RATE_ERP_G = 1<<4,
|
|
|
+};
|
|
|
|
|
|
-struct ieee80211_radiotap_iterator {
|
|
|
- struct ieee80211_radiotap_header *rtheader;
|
|
|
- int max_length;
|
|
|
- int this_arg_index;
|
|
|
- u8 *this_arg;
|
|
|
+/**
|
|
|
+ * struct ieee80211_rate - bitrate definition
|
|
|
+ *
|
|
|
+ * This structure describes a bitrate that an 802.11 PHY can
|
|
|
+ * operate with. The two values @hw_value and @hw_value_short
|
|
|
+ * are only for driver use when pointers to this structure are
|
|
|
+ * passed around.
|
|
|
+ *
|
|
|
+ * @flags: rate-specific flags
|
|
|
+ * @bitrate: bitrate in units of 100 Kbps
|
|
|
+ * @hw_value: driver/hardware value for this rate
|
|
|
+ * @hw_value_short: driver/hardware value for this rate when
|
|
|
+ * short preamble is used
|
|
|
+ */
|
|
|
+struct ieee80211_rate {
|
|
|
+ u32 flags;
|
|
|
+ u16 bitrate;
|
|
|
+ u16 hw_value, hw_value_short;
|
|
|
+};
|
|
|
|
|
|
- int arg_index;
|
|
|
- u8 *arg;
|
|
|
- __le32 *next_bitmap;
|
|
|
- u32 bitmap_shifter;
|
|
|
+/**
|
|
|
+ * struct ieee80211_sta_ht_cap - STA's HT capabilities
|
|
|
+ *
|
|
|
+ * This structure describes most essential parameters needed
|
|
|
+ * to describe 802.11n HT capabilities for an STA.
|
|
|
+ *
|
|
|
+ * @ht_supported: is HT supported by the STA
|
|
|
+ * @cap: HT capabilities map as described in 802.11n spec
|
|
|
+ * @ampdu_factor: Maximum A-MPDU length factor
|
|
|
+ * @ampdu_density: Minimum A-MPDU spacing
|
|
|
+ * @mcs: Supported MCS rates
|
|
|
+ */
|
|
|
+struct ieee80211_sta_ht_cap {
|
|
|
+ u16 cap; /* use IEEE80211_HT_CAP_ */
|
|
|
+ bool ht_supported;
|
|
|
+ u8 ampdu_factor;
|
|
|
+ u8 ampdu_density;
|
|
|
+ struct ieee80211_mcs_info mcs;
|
|
|
};
|
|
|
|
|
|
-extern int ieee80211_radiotap_iterator_init(
|
|
|
- struct ieee80211_radiotap_iterator *iterator,
|
|
|
- struct ieee80211_radiotap_header *radiotap_header,
|
|
|
- int max_length);
|
|
|
+/**
|
|
|
+ * struct ieee80211_supported_band - frequency band definition
|
|
|
+ *
|
|
|
+ * This structure describes a frequency band a wiphy
|
|
|
+ * is able to operate in.
|
|
|
+ *
|
|
|
+ * @channels: Array of channels the hardware can operate in
|
|
|
+ * in this band.
|
|
|
+ * @band: the band this structure represents
|
|
|
+ * @n_channels: Number of channels in @channels
|
|
|
+ * @bitrates: Array of bitrates the hardware can operate with
|
|
|
+ * in this band. Must be sorted to give a valid "supported
|
|
|
+ * rates" IE, i.e. CCK rates first, then OFDM.
|
|
|
+ * @n_bitrates: Number of bitrates in @bitrates
|
|
|
+ */
|
|
|
+struct ieee80211_supported_band {
|
|
|
+ struct ieee80211_channel *channels;
|
|
|
+ struct ieee80211_rate *bitrates;
|
|
|
+ enum ieee80211_band band;
|
|
|
+ int n_channels;
|
|
|
+ int n_bitrates;
|
|
|
+ struct ieee80211_sta_ht_cap ht_cap;
|
|
|
+};
|
|
|
|
|
|
-extern int ieee80211_radiotap_iterator_next(
|
|
|
- struct ieee80211_radiotap_iterator *iterator);
|
|
|
+/*
|
|
|
+ * Wireless hardware/device configuration structures and methods
|
|
|
+ */
|
|
|
|
|
|
+/**
|
|
|
+ * struct vif_params - describes virtual interface parameters
|
|
|
+ * @mesh_id: mesh ID to use
|
|
|
+ * @mesh_id_len: length of the mesh ID
|
|
|
+ */
|
|
|
+struct vif_params {
|
|
|
+ u8 *mesh_id;
|
|
|
+ int mesh_id_len;
|
|
|
+};
|
|
|
|
|
|
- /**
|
|
|
+/**
|
|
|
* struct key_params - key information
|
|
|
*
|
|
|
* Information about a key
|
|
|
@@ -347,92 +494,6 @@ struct bss_parameters {
|
|
|
u8 basic_rates_len;
|
|
|
};
|
|
|
|
|
|
-/**
|
|
|
- * enum environment_cap - Environment parsed from country IE
|
|
|
- * @ENVIRON_ANY: indicates country IE applies to both indoor and
|
|
|
- * outdoor operation.
|
|
|
- * @ENVIRON_INDOOR: indicates country IE applies only to indoor operation
|
|
|
- * @ENVIRON_OUTDOOR: indicates country IE applies only to outdoor operation
|
|
|
- */
|
|
|
-enum environment_cap {
|
|
|
- ENVIRON_ANY,
|
|
|
- ENVIRON_INDOOR,
|
|
|
- ENVIRON_OUTDOOR,
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * struct regulatory_request - used to keep track of regulatory requests
|
|
|
- *
|
|
|
- * @wiphy_idx: this is set if this request's initiator is
|
|
|
- * %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
|
|
|
- * can be used by the wireless core to deal with conflicts
|
|
|
- * and potentially inform users of which devices specifically
|
|
|
- * cased the conflicts.
|
|
|
- * @initiator: indicates who sent this request, could be any of
|
|
|
- * of those set in nl80211_reg_initiator (%NL80211_REGDOM_SET_BY_*)
|
|
|
- * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
|
|
|
- * regulatory domain. We have a few special codes:
|
|
|
- * 00 - World regulatory domain
|
|
|
- * 99 - built by driver but a specific alpha2 cannot be determined
|
|
|
- * 98 - result of an intersection between two regulatory domains
|
|
|
- * @intersect: indicates whether the wireless core should intersect
|
|
|
- * the requested regulatory domain with the presently set regulatory
|
|
|
- * domain.
|
|
|
- * @country_ie_checksum: checksum of the last processed and accepted
|
|
|
- * country IE
|
|
|
- * @country_ie_env: lets us know if the AP is telling us we are outdoor,
|
|
|
- * indoor, or if it doesn't matter
|
|
|
- * @list: used to insert into the reg_requests_list linked list
|
|
|
- */
|
|
|
-struct regulatory_request {
|
|
|
- int wiphy_idx;
|
|
|
- enum nl80211_reg_initiator initiator;
|
|
|
- char alpha2[2];
|
|
|
- bool intersect;
|
|
|
- u32 country_ie_checksum;
|
|
|
- enum environment_cap country_ie_env;
|
|
|
- struct list_head list;
|
|
|
-};
|
|
|
-
|
|
|
-struct ieee80211_freq_range {
|
|
|
- u32 start_freq_khz;
|
|
|
- u32 end_freq_khz;
|
|
|
- u32 max_bandwidth_khz;
|
|
|
-};
|
|
|
-
|
|
|
-struct ieee80211_power_rule {
|
|
|
- u32 max_antenna_gain;
|
|
|
- u32 max_eirp;
|
|
|
-};
|
|
|
-
|
|
|
-struct ieee80211_reg_rule {
|
|
|
- struct ieee80211_freq_range freq_range;
|
|
|
- struct ieee80211_power_rule power_rule;
|
|
|
- u32 flags;
|
|
|
-};
|
|
|
-
|
|
|
-struct ieee80211_regdomain {
|
|
|
- u32 n_reg_rules;
|
|
|
- char alpha2[2];
|
|
|
- struct ieee80211_reg_rule reg_rules[];
|
|
|
-};
|
|
|
-
|
|
|
-#define MHZ_TO_KHZ(freq) ((freq) * 1000)
|
|
|
-#define KHZ_TO_MHZ(freq) ((freq) / 1000)
|
|
|
-#define DBI_TO_MBI(gain) ((gain) * 100)
|
|
|
-#define MBI_TO_DBI(gain) ((gain) / 100)
|
|
|
-#define DBM_TO_MBM(gain) ((gain) * 100)
|
|
|
-#define MBM_TO_DBM(gain) ((gain) / 100)
|
|
|
-
|
|
|
-#define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \
|
|
|
- .freq_range.start_freq_khz = MHZ_TO_KHZ(start), \
|
|
|
- .freq_range.end_freq_khz = MHZ_TO_KHZ(end), \
|
|
|
- .freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \
|
|
|
- .power_rule.max_antenna_gain = DBI_TO_MBI(gain), \
|
|
|
- .power_rule.max_eirp = DBM_TO_MBM(eirp), \
|
|
|
- .flags = reg_flags, \
|
|
|
- }
|
|
|
-
|
|
|
struct mesh_config {
|
|
|
/* Timeouts in ms */
|
|
|
/* Mesh plink management parameters */
|
|
|
@@ -853,7 +914,396 @@ struct cfg80211_ops {
|
|
|
int (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev);
|
|
|
};
|
|
|
|
|
|
-/* temporary wext handlers */
|
|
|
+/*
|
|
|
+ * wireless hardware and networking interfaces structures
|
|
|
+ * and registration/helper functions
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * struct wiphy - wireless hardware description
|
|
|
+ * @idx: the wiphy index assigned to this item
|
|
|
+ * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
|
|
|
+ * @custom_regulatory: tells us the driver for this device
|
|
|
+ * has its own custom regulatory domain and cannot identify the
|
|
|
+ * ISO / IEC 3166 alpha2 it belongs to. When this is enabled
|
|
|
+ * we will disregard the first regulatory hint (when the
|
|
|
+ * initiator is %REGDOM_SET_BY_CORE).
|
|
|
+ * @strict_regulatory: tells us the driver for this device will ignore
|
|
|
+ * regulatory domain settings until it gets its own regulatory domain
|
|
|
+ * via its regulatory_hint(). After its gets its own regulatory domain
|
|
|
+ * it will only allow further regulatory domain settings to further
|
|
|
+ * enhance compliance. For example if channel 13 and 14 are disabled
|
|
|
+ * by this regulatory domain no user regulatory domain can enable these
|
|
|
+ * channels at a later time. This can be used for devices which do not
|
|
|
+ * have calibration information gauranteed for frequencies or settings
|
|
|
+ * outside of its regulatory domain.
|
|
|
+ * @reg_notifier: the driver's regulatory notification callback
|
|
|
+ * @regd: the driver's regulatory domain, if one was requested via
|
|
|
+ * the regulatory_hint() API. This can be used by the driver
|
|
|
+ * on the reg_notifier() if it chooses to ignore future
|
|
|
+ * regulatory domain changes caused by other drivers.
|
|
|
+ * @signal_type: signal type reported in &struct cfg80211_bss.
|
|
|
+ * @cipher_suites: supported cipher suites
|
|
|
+ * @n_cipher_suites: number of supported cipher suites
|
|
|
+ */
|
|
|
+struct wiphy {
|
|
|
+ /* assign these fields before you register the wiphy */
|
|
|
+
|
|
|
+ /* permanent MAC address */
|
|
|
+ u8 perm_addr[ETH_ALEN];
|
|
|
+
|
|
|
+ /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
|
|
|
+ u16 interface_modes;
|
|
|
+
|
|
|
+ bool custom_regulatory;
|
|
|
+ bool strict_regulatory;
|
|
|
+
|
|
|
+ enum cfg80211_signal_type signal_type;
|
|
|
+
|
|
|
+ int bss_priv_size;
|
|
|
+ u8 max_scan_ssids;
|
|
|
+ u16 max_scan_ie_len;
|
|
|
+
|
|
|
+ int n_cipher_suites;
|
|
|
+ const u32 *cipher_suites;
|
|
|
+
|
|
|
+ /* If multiple wiphys are registered and you're handed e.g.
|
|
|
+ * a regular netdev with assigned ieee80211_ptr, you won't
|
|
|
+ * know whether it points to a wiphy your driver has registered
|
|
|
+ * or not. Assign this to something global to your driver to
|
|
|
+ * help determine whether you own this wiphy or not. */
|
|
|
+ void *privid;
|
|
|
+
|
|
|
+ struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];
|
|
|
+
|
|
|
+ /* Lets us get back the wiphy on the callback */
|
|
|
+ int (*reg_notifier)(struct wiphy *wiphy,
|
|
|
+ struct regulatory_request *request);
|
|
|
+
|
|
|
+ /* fields below are read-only, assigned by cfg80211 */
|
|
|
+
|
|
|
+ const struct ieee80211_regdomain *regd;
|
|
|
+
|
|
|
+ /* the item in /sys/class/ieee80211/ points to this,
|
|
|
+ * you need use set_wiphy_dev() (see below) */
|
|
|
+ struct device dev;
|
|
|
+
|
|
|
+ /* dir in debugfs: ieee80211/<wiphyname> */
|
|
|
+ struct dentry *debugfsdir;
|
|
|
+
|
|
|
+ char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_priv - return priv from wiphy
|
|
|
+ *
|
|
|
+ * @wiphy: the wiphy whose priv pointer to return
|
|
|
+ */
|
|
|
+static inline void *wiphy_priv(struct wiphy *wiphy)
|
|
|
+{
|
|
|
+ BUG_ON(!wiphy);
|
|
|
+ return &wiphy->priv;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * set_wiphy_dev - set device pointer for wiphy
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy whose device to bind
|
|
|
+ * @dev: The device to parent it to
|
|
|
+ */
|
|
|
+static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
|
|
|
+{
|
|
|
+ wiphy->dev.parent = dev;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_dev - get wiphy dev pointer
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy whose device struct to look up
|
|
|
+ */
|
|
|
+static inline struct device *wiphy_dev(struct wiphy *wiphy)
|
|
|
+{
|
|
|
+ return wiphy->dev.parent;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_name - get wiphy name
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy whose name to return
|
|
|
+ */
|
|
|
+static inline const char *wiphy_name(struct wiphy *wiphy)
|
|
|
+{
|
|
|
+ return dev_name(&wiphy->dev);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_new - create a new wiphy for use with cfg80211
|
|
|
+ *
|
|
|
+ * @ops: The configuration operations for this device
|
|
|
+ * @sizeof_priv: The size of the private area to allocate
|
|
|
+ *
|
|
|
+ * Create a new wiphy and associate the given operations with it.
|
|
|
+ * @sizeof_priv bytes are allocated for private use.
|
|
|
+ *
|
|
|
+ * The returned pointer must be assigned to each netdev's
|
|
|
+ * ieee80211_ptr for proper operation.
|
|
|
+ */
|
|
|
+struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv);
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_register - register a wiphy with cfg80211
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy to register.
|
|
|
+ *
|
|
|
+ * Returns a non-negative wiphy index or a negative error code.
|
|
|
+ */
|
|
|
+extern int wiphy_register(struct wiphy *wiphy);
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_unregister - deregister a wiphy from cfg80211
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy to unregister.
|
|
|
+ *
|
|
|
+ * After this call, no more requests can be made with this priv
|
|
|
+ * pointer, but the call may sleep to wait for an outstanding
|
|
|
+ * request that is being handled.
|
|
|
+ */
|
|
|
+extern void wiphy_unregister(struct wiphy *wiphy);
|
|
|
+
|
|
|
+/**
|
|
|
+ * wiphy_free - free wiphy
|
|
|
+ *
|
|
|
+ * @wiphy: The wiphy to free
|
|
|
+ */
|
|
|
+extern void wiphy_free(struct wiphy *wiphy);
|
|
|
+
|
|
|
+/**
|
|
|
+ * struct wireless_dev - wireless per-netdev state
|
|
|
+ *
|
|
|
+ * This structure must be allocated by the driver/stack
|
|
|
+ * that uses the ieee80211_ptr field in struct net_device
|
|
|
+ * (this is intentional so it can be allocated along with
|
|
|
+ * the netdev.)
|
|
|
+ *
|
|
|
+ * @wiphy: pointer to hardware description
|
|
|
+ * @iftype: interface type
|
|
|
+ * @list: (private) Used to collect the interfaces
|
|
|
+ * @netdev: (private) Used to reference back to the netdev
|
|
|
+ * @current_bss: (private) Used by the internal configuration code
|
|
|
+ * @bssid: (private) Used by the internal configuration code
|
|
|
+ * @ssid: (private) Used by the internal configuration code
|
|
|
+ * @ssid_len: (private) Used by the internal configuration code
|
|
|
+ * @wext: (private) Used by the internal wireless extensions compat code
|
|
|
+ * @wext_bssid: (private) Used by the internal wireless extensions compat code
|
|
|
+ */
|
|
|
+struct wireless_dev {
|
|
|
+ struct wiphy *wiphy;
|
|
|
+ enum nl80211_iftype iftype;
|
|
|
+
|
|
|
+ /* private to the generic wireless code */
|
|
|
+ struct list_head list;
|
|
|
+ struct net_device *netdev;
|
|
|
+
|
|
|
+ /* currently used for IBSS - might be rearranged in the future */
|
|
|
+ struct cfg80211_bss *current_bss;
|
|
|
+ u8 bssid[ETH_ALEN];
|
|
|
+ u8 ssid[IEEE80211_MAX_SSID_LEN];
|
|
|
+ u8 ssid_len;
|
|
|
+
|
|
|
+#ifdef CONFIG_WIRELESS_EXT
|
|
|
+ /* wext data */
|
|
|
+ struct cfg80211_ibss_params wext;
|
|
|
+ u8 wext_bssid[ETH_ALEN];
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * wdev_priv - return wiphy priv from wireless_dev
|
|
|
+ *
|
|
|
+ * @wdev: The wireless device whose wiphy's priv pointer to return
|
|
|
+ */
|
|
|
+static inline void *wdev_priv(struct wireless_dev *wdev)
|
|
|
+{
|
|
|
+ BUG_ON(!wdev);
|
|
|
+ return wiphy_priv(wdev->wiphy);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * Utility functions
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * ieee80211_channel_to_frequency - convert channel number to frequency
|
|
|
+ */
|
|
|
+extern int ieee80211_channel_to_frequency(int chan);
|
|
|
+
|
|
|
+/**
|
|
|
+ * ieee80211_frequency_to_channel - convert frequency to channel number
|
|
|
+ */
|
|
|
+extern int ieee80211_frequency_to_channel(int freq);
|
|
|
+
|
|
|
+/*
|
|
|
+ * Name indirection necessary because the ieee80211 code also has
|
|
|
+ * a function named "ieee80211_get_channel", so if you include
|
|
|
+ * cfg80211's header file you get cfg80211's version, if you try
|
|
|
+ * to include both header files you'll (rightfully!) get a symbol
|
|
|
+ * clash.
|
|
|
+ */
|
|
|
+extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy,
|
|
|
+ int freq);
|
|
|
+/**
|
|
|
+ * ieee80211_get_channel - get channel struct from wiphy for specified frequency
|
|
|
+ */
|
|
|
+static inline struct ieee80211_channel *
|
|
|
+ieee80211_get_channel(struct wiphy *wiphy, int freq)
|
|
|
+{
|
|
|
+ return __ieee80211_get_channel(wiphy, freq);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * ieee80211_get_response_rate - get basic rate for a given rate
|
|
|
+ *
|
|
|
+ * @sband: the band to look for rates in
|
|
|
+ * @basic_rates: bitmap of basic rates
|
|
|
+ * @bitrate: the bitrate for which to find the basic rate
|
|
|
+ *
|
|
|
+ * This function returns the basic rate corresponding to a given
|
|
|
+ * bitrate, that is the next lower bitrate contained in the basic
|
|
|
+ * rate map, which is, for this function, given as a bitmap of
|
|
|
+ * indices of rates in the band's bitrate table.
|
|
|
+ */
|
|
|
+struct ieee80211_rate *
|
|
|
+ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
|
|
|
+ u32 basic_rates, int bitrate);
|
|
|
+
|
|
|
+/*
|
|
|
+ * Radiotap parsing functions -- for controlled injection support
|
|
|
+ *
|
|
|
+ * Implemented in net/wireless/radiotap.c
|
|
|
+ * Documentation in Documentation/networking/radiotap-headers.txt
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
|
|
|
+ * @rtheader: pointer to the radiotap header we are walking through
|
|
|
+ * @max_length: length of radiotap header in cpu byte ordering
|
|
|
+ * @this_arg_index: IEEE80211_RADIOTAP_... index of current arg
|
|
|
+ * @this_arg: pointer to current radiotap arg
|
|
|
+ * @arg_index: internal next argument index
|
|
|
+ * @arg: internal next argument pointer
|
|
|
+ * @next_bitmap: internal pointer to next present u32
|
|
|
+ * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
|
|
|
+ */
|
|
|
+
|
|
|
+struct ieee80211_radiotap_iterator {
|
|
|
+ struct ieee80211_radiotap_header *rtheader;
|
|
|
+ int max_length;
|
|
|
+ int this_arg_index;
|
|
|
+ u8 *this_arg;
|
|
|
+
|
|
|
+ int arg_index;
|
|
|
+ u8 *arg;
|
|
|
+ __le32 *next_bitmap;
|
|
|
+ u32 bitmap_shifter;
|
|
|
+};
|
|
|
+
|
|
|
+extern int ieee80211_radiotap_iterator_init(
|
|
|
+ struct ieee80211_radiotap_iterator *iterator,
|
|
|
+ struct ieee80211_radiotap_header *radiotap_header,
|
|
|
+ int max_length);
|
|
|
+
|
|
|
+extern int ieee80211_radiotap_iterator_next(
|
|
|
+ struct ieee80211_radiotap_iterator *iterator);
|
|
|
+
|
|
|
+/*
|
|
|
+ * Regulatory helper functions for wiphys
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * regulatory_hint - driver hint to the wireless core a regulatory domain
|
|
|
+ * @wiphy: the wireless device giving the hint (used only for reporting
|
|
|
+ * conflicts)
|
|
|
+ * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
|
|
|
+ * should be in. If @rd is set this should be NULL. Note that if you
|
|
|
+ * set this to NULL you should still set rd->alpha2 to some accepted
|
|
|
+ * alpha2.
|
|
|
+ *
|
|
|
+ * Wireless drivers can use this function to hint to the wireless core
|
|
|
+ * what it believes should be the current regulatory domain by
|
|
|
+ * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
|
|
|
+ * domain should be in or by providing a completely build regulatory domain.
|
|
|
+ * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
|
|
|
+ * for a regulatory domain structure for the respective country.
|
|
|
+ *
|
|
|
+ * The wiphy must have been registered to cfg80211 prior to this call.
|
|
|
+ * For cfg80211 drivers this means you must first use wiphy_register(),
|
|
|
+ * for mac80211 drivers you must first use ieee80211_register_hw().
|
|
|
+ *
|
|
|
+ * Drivers should check the return value, its possible you can get
|
|
|
+ * an -ENOMEM.
|
|
|
+ */
|
|
|
+extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2);
|
|
|
+
|
|
|
+/**
|
|
|
+ * regulatory_hint_11d - hints a country IE as a regulatory domain
|
|
|
+ * @wiphy: the wireless device giving the hint (used only for reporting
|
|
|
+ * conflicts)
|
|
|
+ * @country_ie: pointer to the country IE
|
|
|
+ * @country_ie_len: length of the country IE
|
|
|
+ *
|
|
|
+ * We will intersect the rd with the what CRDA tells us should apply
|
|
|
+ * for the alpha2 this country IE belongs to, this prevents APs from
|
|
|
+ * sending us incorrect or outdated information against a country.
|
|
|
+ */
|
|
|
+extern void regulatory_hint_11d(struct wiphy *wiphy,
|
|
|
+ u8 *country_ie,
|
|
|
+ u8 country_ie_len);
|
|
|
+/**
|
|
|
+ * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain
|
|
|
+ * @wiphy: the wireless device we want to process the regulatory domain on
|
|
|
+ * @regd: the custom regulatory domain to use for this wiphy
|
|
|
+ *
|
|
|
+ * Drivers can sometimes have custom regulatory domains which do not apply
|
|
|
+ * to a specific country. Drivers can use this to apply such custom regulatory
|
|
|
+ * domains. This routine must be called prior to wiphy registration. The
|
|
|
+ * custom regulatory domain will be trusted completely and as such previous
|
|
|
+ * default channel settings will be disregarded. If no rule is found for a
|
|
|
+ * channel on the regulatory domain the channel will be disabled.
|
|
|
+ */
|
|
|
+extern void wiphy_apply_custom_regulatory(
|
|
|
+ struct wiphy *wiphy,
|
|
|
+ const struct ieee80211_regdomain *regd);
|
|
|
+
|
|
|
+/**
|
|
|
+ * freq_reg_info - get regulatory information for the given frequency
|
|
|
+ * @wiphy: the wiphy for which we want to process this rule for
|
|
|
+ * @center_freq: Frequency in KHz for which we want regulatory information for
|
|
|
+ * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
|
|
|
+ * you can set this to 0. If this frequency is allowed we then set
|
|
|
+ * this value to the maximum allowed bandwidth.
|
|
|
+ * @reg_rule: the regulatory rule which we have for this frequency
|
|
|
+ *
|
|
|
+ * Use this function to get the regulatory rule for a specific frequency on
|
|
|
+ * a given wireless device. If the device has a specific regulatory domain
|
|
|
+ * it wants to follow we respect that unless a country IE has been received
|
|
|
+ * and processed already.
|
|
|
+ *
|
|
|
+ * Returns 0 if it was able to find a valid regulatory rule which does
|
|
|
+ * apply to the given center_freq otherwise it returns non-zero. It will
|
|
|
+ * also return -ERANGE if we determine the given center_freq does not even have
|
|
|
+ * a regulatory rule for a frequency range in the center_freq's band. See
|
|
|
+ * freq_in_rule_band() for our current definition of a band -- this is purely
|
|
|
+ * subjective and right now its 802.11 specific.
|
|
|
+ */
|
|
|
+extern int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
|
|
|
+ const struct ieee80211_reg_rule **reg_rule);
|
|
|
+
|
|
|
+/*
|
|
|
+ * Temporary wext handlers & helper functions
|
|
|
+ *
|
|
|
+ * In the future cfg80211 will simply assign the entire wext handler
|
|
|
+ * structure to netdevs it manages, but we're not there yet.
|
|
|
+ */
|
|
|
int cfg80211_wext_giwname(struct net_device *dev,
|
|
|
struct iw_request_info *info,
|
|
|
char *name, char *extra);
|
|
|
@@ -892,10 +1342,14 @@ int cfg80211_ibss_wext_giwap(struct net_device *dev,
|
|
|
struct iw_request_info *info,
|
|
|
struct sockaddr *ap_addr, char *extra);
|
|
|
|
|
|
-/* wext helper for now (to be removed) */
|
|
|
struct ieee80211_channel *cfg80211_wext_freq(struct wiphy *wiphy,
|
|
|
struct iw_freq *freq);
|
|
|
|
|
|
+/*
|
|
|
+ * callbacks for asynchronous cfg80211 methods, notification
|
|
|
+ * functions and BSS handling helpers
|
|
|
+ */
|
|
|
+
|
|
|
/**
|
|
|
* cfg80211_scan_done - notify that scan finished
|
|
|
*
|
|
|
@@ -949,6 +1403,7 @@ struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy,
|
|
|
const u8 *meshid, size_t meshidlen,
|
|
|
const u8 *meshcfg);
|
|
|
void cfg80211_put_bss(struct cfg80211_bss *bss);
|
|
|
+
|
|
|
/**
|
|
|
* cfg80211_unlink_bss - unlink BSS from internal data structures
|
|
|
* @wiphy: the wiphy
|
Johannes Berg