forked from Minki/linux
9306102ea5
This patch allows to disable FAT channel in specific configurations. For example the configuration (8, +1), (primary channel 8, extension channel 12) isn't permitted in U.S., but (8, -1), (primary channel 8, extension channel 4) is. When FAT channel configuration is not permitted, FAT channel should be reported as not supported in the capabilities of the HT IE in association request. And sssociation is performed on 20Mhz channel. Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com> Signed-off-by: Tomas Winkler <tomas.winkler@intel.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
332 lines
9.1 KiB
C
332 lines
9.1 KiB
C
#ifndef __NET_WIRELESS_H
|
|
#define __NET_WIRELESS_H
|
|
|
|
/*
|
|
* 802.11 device management
|
|
*
|
|
* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
|
|
*/
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/list.h>
|
|
#include <net/cfg80211.h>
|
|
|
|
/**
|
|
* enum ieee80211_band - supported frequency bands
|
|
*
|
|
* The bands are assigned this way because the supported
|
|
* bitrates differ in these bands.
|
|
*
|
|
* @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
|
|
};
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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,
|
|
};
|
|
|
|
/**
|
|
* struct ieee80211_channel - channel definition
|
|
*
|
|
* This structure describes a single channel for use
|
|
* with cfg80211.
|
|
*
|
|
* @center_freq: center frequency 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)
|
|
* @orig_mag: internal use
|
|
* @orig_mpwr: internal use
|
|
*/
|
|
struct ieee80211_channel {
|
|
enum ieee80211_band band;
|
|
u16 center_freq;
|
|
u16 hw_value;
|
|
u32 flags;
|
|
int max_antenna_gain;
|
|
int max_power;
|
|
u32 orig_flags;
|
|
int orig_mag, orig_mpwr;
|
|
};
|
|
|
|
/**
|
|
* 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_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;
|
|
};
|
|
|
|
/**
|
|
* struct ieee80211_ht_info - describing 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 STA, 0: no, 1: yes
|
|
* @cap: HT capabilities map as described in 802.11n spec
|
|
* @ampdu_factor: Maximum A-MPDU length factor
|
|
* @ampdu_density: Minimum A-MPDU spacing
|
|
* @supp_mcs_set: Supported MCS set as described in 802.11n spec
|
|
*/
|
|
struct ieee80211_ht_info {
|
|
u16 cap; /* use IEEE80211_HT_CAP_ */
|
|
u8 ht_supported;
|
|
u8 ampdu_factor;
|
|
u8 ampdu_density;
|
|
u8 supp_mcs_set[16];
|
|
};
|
|
|
|
/**
|
|
* 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_ht_info ht_info;
|
|
};
|
|
|
|
/**
|
|
* struct wiphy - wireless hardware description
|
|
* @idx: the wiphy index assigned to this item
|
|
* @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
|
|
*/
|
|
struct wiphy {
|
|
/* assign these fields before you register the wiphy */
|
|
|
|
/* permanent MAC address */
|
|
u8 perm_addr[ETH_ALEN];
|
|
|
|
/* 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];
|
|
|
|
/* fields below are read-only, assigned by cfg80211 */
|
|
|
|
/* 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)));
|
|
};
|
|
|
|
/** 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
|
|
*/
|
|
struct wireless_dev {
|
|
struct wiphy *wiphy;
|
|
|
|
/* private to the generic wireless code */
|
|
struct list_head list;
|
|
struct net_device *netdev;
|
|
};
|
|
|
|
/**
|
|
* wiphy_priv - return priv from wiphy
|
|
*/
|
|
static inline void *wiphy_priv(struct wiphy *wiphy)
|
|
{
|
|
BUG_ON(!wiphy);
|
|
return &wiphy->priv;
|
|
}
|
|
|
|
/**
|
|
* set_wiphy_dev - set device pointer for wiphy
|
|
*/
|
|
static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
|
|
{
|
|
wiphy->dev.parent = dev;
|
|
}
|
|
|
|
/**
|
|
* wiphy_dev - get wiphy dev pointer
|
|
*/
|
|
static inline struct device *wiphy_dev(struct wiphy *wiphy)
|
|
{
|
|
return wiphy->dev.parent;
|
|
}
|
|
|
|
/**
|
|
* wiphy_name - get wiphy name
|
|
*/
|
|
static inline char *wiphy_name(struct wiphy *wiphy)
|
|
{
|
|
return wiphy->dev.bus_id;
|
|
}
|
|
|
|
/**
|
|
* wdev_priv - return wiphy priv from wireless_dev
|
|
*/
|
|
static inline void *wdev_priv(struct wireless_dev *wdev)
|
|
{
|
|
BUG_ON(!wdev);
|
|
return wiphy_priv(wdev->wiphy);
|
|
}
|
|
|
|
/**
|
|
* wiphy_new - create a new wiphy for use with cfg80211
|
|
*
|
|
* 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
|
|
*
|
|
* register the given wiphy
|
|
*
|
|
* 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
|
|
*
|
|
* unregister a device with the given priv pointer.
|
|
* 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
|
|
*/
|
|
extern void wiphy_free(struct wiphy *wiphy);
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
#endif /* __NET_WIRELESS_H */
|